diff --git a/.github/actions/log-cpu/action.yml b/.github/actions/log-cpu/action.yml
index 69ae6dc05..b47cea486 100644
--- a/.github/actions/log-cpu/action.yml
+++ b/.github/actions/log-cpu/action.yml
@@ -30,6 +30,32 @@ inputs:
 runs:
   using: composite
   steps:
+    # PR benchmarks execute trusted workflow YAML from the default branch but
+    # load this action from the PR checkout. Ensure a freshly checked-out base
+    # has its pinned Rust toolchain before Lake invokes Cargo.
+    - name: Bootstrap base Rust toolchain
+      if: inputs.label == 'Base benchmark binary build CPU'
+      shell: bash
+      run: |
+        set -euo pipefail
+
+        toolchain_file=base/rust-toolchain.toml
+        [ -f "$toolchain_file" ] || { echo "::error::$toolchain_file is missing"; exit 1; }
+        channel=$(awk -F '"' '/^[[:space:]]*channel[[:space:]]*=/ { print $2; exit }' "$toolchain_file")
+        profile=$(awk -F '"' '/^[[:space:]]*profile[[:space:]]*=/ { print $2; exit }' "$toolchain_file")
+        if [[ ! "$channel" =~ ^[A-Za-z0-9._+-]+$ ]]; then
+          echo "::error::$toolchain_file has an invalid Rust channel"
+          exit 1
+        fi
+        case "${profile:-default}" in
+          minimal|default|complete) ;;
+          *) echo "::error::$toolchain_file has an invalid Rust profile"; exit 1 ;;
+        esac
+
+        rustup run "$channel" rustc --version >/dev/null 2>&1 && exit 0
+        echo "Installing Rust $channel (${profile:-default} profile) for the fresh base build"
+        rustup toolchain install "$channel" --profile "${profile:-default}" --no-self-update
+
     - shell: bash
       env:
         CPU_LABEL: ${{ inputs.label }}
diff --git a/Benchmarks/AggregatePolicy.lean b/Benchmarks/AggregatePolicy.lean
new file mode 100644
index 000000000..b04281df0
--- /dev/null
+++ b/Benchmarks/AggregatePolicy.lean
@@ -0,0 +1,764 @@
+import Ix.Cli.AggregateCmd
+import Ix.Benchmark.Bench
+import Ix.TracingTexray
+
+/-!
+# Four-shard converged aggregation policy benchmark
+
+This executable is the M1-f handoff harness. It consumes four persisted IxVM
+shard proofs from a validated manifest, derives the selected subtree from the
+manifest aggregation tree, and measures either production wrap-first or
+non-default direct joins through the single `ix_aggr` entrypoint.
+
+Base shard proving is deliberately out of scope. Every input and recursive
+output is natively verified, every recursive output is persisted as an ordinary
+`Ixon.Proof` wrapper, aggregate cache access is disabled, and a structured JSON
+report is rewritten after every completed slot.
+-/
+
+open Lean (Json)
+
+namespace Benchmarks.AggregatePolicy
+
+open Ix
+open Ix.Cli.AggregateCmd
+
+abbrev AggregationTree := Ix.Cli.CheckCmd.AggregationTree
+abbrev FoldOp := Ix.Cli.CheckCmd.AggregationTree.FoldOp
+
+inductive Policy where
+  | wrapFirst
+  | direct
+  deriving BEq, Repr
+
+def Policy.parse : String → Except String Policy
+  | "wrap-first" => .ok .wrapFirst
+  | "direct" => .ok .direct
+  | value => .error s!"invalid --policy {value}; expected wrap-first or direct"
+
+def Policy.label : Policy → String
+  | .wrapFirst => "wrap-first"
+  | .direct => "direct"
+
+def Policy.directJoins : Policy → Bool
+  | .wrapFirst => false
+  | .direct => true
+
+def argStr (args : List String) (flag : String) : Option String :=
+  match args.dropWhile (· != flag) with
+  | _ :: value :: _ => some value
+  | _ => none
+
+def argNat? (args : List String) (flag : String) : Option Nat :=
+  (argStr args flag).bind (·.toNat?)
+
+def hasFlag (args : List String) (flag : String) : Bool :=
+  args.contains flag
+
+def jsonRound (digits : Nat) (value : Float) : Json :=
+  let scale := (10.0 : Float) ^ digits.toFloat
+  let scaled := value * scale
+  let mantissa : _root_.Int :=
+    if scaled < 0 then -_root_.Int.ofNat (-scaled).round.toUInt64.toNat
+    else _root_.Int.ofNat scaled.round.toUInt64.toNat
+  Json.num ⟨mantissa, digits⟩
+
+def timed (action : Unit → α) : IO (α × Float) := do
+  let started ← IO.monoNanosNow
+  let result ← blackBoxIO action ()
+  let elapsed ← IO.monoNanosNow
+  pure (result, (elapsed - started).toFloat / 1e9)
+
+def parseShardIds (value : String) : Except String (Array Nat) := do
+  let parts := value.splitOn ","
+  if parts.length != 4 then
+    throw s!"--shards must contain exactly four comma-separated ids; got {parts.length}"
+  let mut ids : Array Nat := #[]
+  for part in parts do
+    let some shard := part.toNat?
+      | throw s!"invalid shard id in --shards: {part}"
+    if ids.contains shard then
+      throw s!"--shards repeats shard {shard}"
+    ids := ids.push shard
+  pure ids
+
+def compileToplevel (label : String)
+    (source : Except Aiur.Global Aiur.Source.Toplevel) :
+    IO (Except String Aiur.CompiledToplevel) := do
+  match source with
+  | .error error => pure (.error s!"{label} toplevel merge failed: {error}")
+  | .ok top => match top.compile with
+    | .error error => pure (.error s!"{label} compilation failed: {error}")
+    | .ok compiled => pure (.ok compiled)
+
+def prepareShard (env : Ixon.Env) (blocks : Array Address) :
+    Except String PreparedShard := do
+  let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks
+  let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned
+  let statement ← MultiStark.CheckEnvTrees.ofClaim claim trees
+  pure { claim, statement }
+
+structure Fixture where
+  shardIds : Array Nat
+  blocks : Array (Array Address)
+  subjectCounts : Array Nat
+  tree : AggregationTree
+  prepared : Array PreparedShard
+
+/-- Select four retained manifest shards and contract every other tree leaf.
+The requested-id order determines dense indices; tree topology and left/right
+orientation remain those of the manifest. -/
+def selectFixture (env : Ixon.Env) (view : Ix.Cli.CheckCmd.IxesManifestView)
+    (counts requestedIds : Array Nat) : Except String Fixture := do
+  if requestedIds.size != 4 then
+    throw "internal: policy benchmark requires exactly four shards"
+  if view.shards.size != counts.size || view.shards.size != view.shardIds.size then
+    throw "manifest view/count cardinality mismatch"
+  let mut remap : Array (Option Nat) := Array.replicate view.shards.size none
+  let mut blocks : Array (Array Address) := #[]
+  let mut selectedCounts : Array Nat := #[]
+  let mut prepared : Array PreparedShard := #[]
+  for (originalId, selectedIdx) in
+      requestedIds.mapIdx fun selectedIdx originalId => (originalId, selectedIdx) do
+    let some denseIdx := view.shardIds.findIdx? (· == originalId)
+      | throw s!"manifest has no retained shard {originalId}"
+    let some shardBlocks := view.shards[denseIdx]?
+      | throw s!"manifest is missing blocks for retained shard {originalId}"
+    let some subjectCount := counts[denseIdx]?
+      | throw s!"manifest is missing the subject count for retained shard {originalId}"
+    remap := remap.set! denseIdx (some selectedIdx)
+    blocks := blocks.push shardBlocks
+    selectedCounts := selectedCounts.push subjectCount
+    prepared := prepared.push (← prepareShard env shardBlocks)
+  let some tree := view.aggregationTree.pruneAndRemap remap
+    | throw "selected shards produced an empty aggregation tree"
+  if tree.leaves.size != 4 then
+    throw s!"selected aggregation tree has {tree.leaves.size} leaves, expected 4"
+  let fixture : Fixture := {
+    shardIds := requestedIds
+    blocks := blocks
+    subjectCounts := selectedCounts
+    tree := tree
+    prepared := prepared
+  }
+  pure fixture
+
+/-- Recompute the host fold without claims, verifying that the benchmark root
+is exactly the selected manifest subtree rather than a full-environment root. -/
+def expectedStatements (plan : Array ScheduledFold)
+    (prepared : Array PreparedShard) :
+    Except String (Array MultiStark.CheckEnvTrees) := do
+  let mut statements : Array MultiStark.CheckEnvTrees := #[]
+  for item in plan do
+    match item.op with
+    | .leaf shard =>
+      let some source := prepared[shard]?
+        | throw s!"expected fold references missing shard {shard}"
+      statements := statements.push source.statement
+    | .join leftIdx rightIdx =>
+      let some left := statements[leftIdx]?
+        | throw s!"expected fold references missing left slot {leftIdx}"
+      let some right := statements[rightIdx]?
+        | throw s!"expected fold references missing right slot {rightIdx}"
+      let left := toAggrCheckEnvTrees left
+      let right := toAggrCheckEnvTrees right
+      let output := if item.structural then left.joinStructural right
+        else left.join right
+      statements := statements.push (fromAggrCheckEnvTrees output)
+  pure statements
+
+def childKindLabel : Aggr.ChildKind → String
+  | .ixvm => "ixvm"
+  | .aggr => "ix_aggr"
+
+def optionNatJson : Option Nat → Json
+  | none => Json.null
+  | some value => Lean.toJson value
+
+def planOperation (item : ScheduledFold) : String :=
+  match item.op with
+  | .leaf _ => if item.kind == .ixvm then "raw" else "wrap"
+  | .join _ _ => if item.structural then "structural-join" else "flat-join"
+
+def planRows (plan : Array ScheduledFold) (shardIds : Array Nat) : Array Json :=
+  plan.mapIdx fun slotIdx item =>
+    let base : List (String × Json) :=
+      [("slot", Lean.toJson slotIdx),
+       ("operation", Json.str (planOperation item)),
+       ("shape", optionNatJson item.shape?),
+       ("subject_count", Lean.toJson item.subjectCount),
+       ("ram_weight_bytes", Lean.toJson (aggregateSlotRamBytes item))]
+    match item.op with
+    | .leaf shard =>
+      Json.mkObj (base ++
+        [("shard", Lean.toJson ((shardIds[shard]?).getD shard)),
+         ("left_kind", Json.str (childKindLabel item.kind)),
+         ("right_kind", Json.null)])
+    | .join leftIdx rightIdx =>
+      let leftKind := (plan[leftIdx]?).map (childKindLabel ·.kind)
+        |>.getD "missing"
+      let rightKind := (plan[rightIdx]?).map (childKindLabel ·.kind)
+        |>.getD "missing"
+      Json.mkObj (base ++
+        [("left_slot", Lean.toJson leftIdx),
+         ("right_slot", Lean.toJson rightIdx),
+         ("left_kind", Json.str leftKind),
+         ("right_kind", Json.str rightKind)])
+
+def printPlan (policy : Policy) (plan : Array ScheduledFold)
+    (shardIds : Array Nat) (structuralAbove : Nat) : IO Unit := do
+  IO.println s!"[aggregate-policy] {policy.label}; structural threshold > {structuralAbove}"
+  for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do
+    match item.op with
+    | .leaf shard =>
+      let originalShard := (shardIds[shard]?).getD shard
+      IO.println s!"  slot {slotIdx}: {planOperation item} shard {originalShard}; \
+        shape {item.shape?.map toString |>.getD "raw"}; {item.subjectCount} subjects"
+    | .join left right =>
+      IO.println s!"  slot {slotIdx}: {planOperation item} slots {left},{right}; \
+        shape {item.shape?.map toString |>.getD "missing"}; {item.subjectCount} subjects"
+
+structure InputProof where
+  address : Address
+  wrapper : Ixon.Proof
+  proof : Aiur.Proof
+  innerClaim : Array Aiur.G
+  claimsBytes : ByteArray
+
+def loadInputProof (shardId : Nat) (proofAddress : String)
+    (prepared : PreparedShard) (verifyIdx : Aiur.Bytecode.FunIdx) :
+    IO (Except String InputProof) := do
+  let some address := Address.fromString proofAddress
+    | return .error s!"--proof-{shardId}: expected a 64-character store address"
+  try
+    let wrapper ← match Ixon.Proof.de (← StoreIO.toIO (Store.read address)) with
+      | .error error =>
+        return .error s!"shard {shardId}: wrapper decode failed: {error}"
+      | .ok wrapper => pure wrapper
+    if wrapper.claim != prepared.claim then
+      return .error s!"shard {shardId}: persisted wrapper claim does not match the selected shard"
+    let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with
+      | .error error =>
+        return .error s!"shard {shardId}: proof decode failed: {error}"
+      | .ok proof => pure proof
+    let claimBytes := Ix.Claim.ser prepared.claim
+    let innerClaim := Aiur.buildClaim verifyIdx
+      (IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes)) #[]
+    let input : InputProof := {
+      address := address
+      wrapper := wrapper
+      proof := proof
+      innerClaim := innerClaim
+      claimsBytes := MultiStark.serializeClaims #[innerClaim]
+    }
+    pure (.ok input)
+  catch error =>
+    pure (.error s!"shard {shardId}: store read failed: {error}")
+
+def persistAggregateProof (statement : MultiStark.CheckEnvTrees)
+    (proof : Aiur.Proof) : IO Address := do
+  let claim := statement.claim
+  let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim))
+  let wrapper : Ixon.Proof := { claim, proof := proof.toBytes }
+  StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper))
+
+structure MeasuredSlot where
+  slot : AggregateSlot
+  row : Json
+  proveSeconds : Float
+  peakTreeRssBytes : Nat
+
+def stageRow (slotIdx : Nat) (item : ScheduledFold)
+    (leftKind rightKind : Option Aggr.ChildKind) (proveSeconds verifySeconds : Float)
+    (inputVerifySeconds : Option Float) (peakTreeRssBytes proofBytes : Nat)
+    (claimDigest proofAddress : Address) : Json :=
+  Json.mkObj <|
+    [("slot", Lean.toJson slotIdx),
+     ("operation", Json.str (planOperation item)),
+     ("shape", optionNatJson item.shape?),
+     ("left_kind", leftKind.map (Json.str ∘ childKindLabel) |>.getD Json.null),
+     ("right_kind", rightKind.map (Json.str ∘ childKindLabel) |>.getD Json.null),
+     ("subject_count", Lean.toJson item.subjectCount),
+     ("prove_seconds", jsonRound 6 proveSeconds),
+     ("verify_seconds", jsonRound 6 verifySeconds),
+     ("peak_tree_rss_bytes", Lean.toJson peakTreeRssBytes),
+     ("proof_bytes", Lean.toJson proofBytes),
+     ("claim_digest", Json.str (toString claimDigest)),
+     ("proof_address", Json.str (toString proofAddress))] ++
+    match inputVerifySeconds with
+    | none => []
+    | some seconds => [("input_verify_seconds", jsonRound 6 seconds)]
+
+def runLeaf (slotIdx shardId : Nat) (item : ScheduledFold)
+    (prepared : PreparedShard) (input : InputProof) (spec : AggregateSlotSpec)
+    (ixvmSystem aggrSystem : Aiur.AiurSystem) (ixvmVk aggrVk allowed : ByteArray)
+    (aggrIdx : Aiur.Bytecode.FunIdx) : IO (Except String MeasuredSlot) := do
+  TracingTexray.resetPeakTreeRss
+  let (innerVerified, innerVerifySeconds) ← timed fun _ =>
+    ixvmSystem.verify input.innerClaim input.proof
+  let innerVerifyPeak ← TracingTexray.peakTreeRssBytes
+  match innerVerified with
+  | .error error =>
+    return .error s!"shard {shardId}: native input verification failed: {error}"
+  | .ok () => pure ()
+  if spec.outerClaim != (if item.kind == .ixvm then input.innerClaim
+      else aggregateOuterClaim allowed aggrIdx prepared.claim) then
+    return .error s!"shard {shardId}: prepared leaf outer claim is inconsistent"
+  match item.kind with
+  | .ixvm =>
+    if item.shape?.isSome then
+      return .error s!"shard {shardId}: raw leaf unexpectedly has an ix_aggr shape"
+    let slot : AggregateSlot := {
+      kind := .ixvm, statement := spec.statement,
+      subjectCount := spec.subjectCount, outerClaim := input.innerClaim,
+      proof := input.proof, proofAddress? := some input.address,
+      claimsBytes := input.claimsBytes
+    }
+    pure (.ok {
+      slot
+      row := stageRow slotIdx item (some .ixvm) none 0 innerVerifySeconds none
+        innerVerifyPeak input.wrapper.proof.size
+        (Address.blake3 (Ix.Claim.ser spec.statement.claim)) input.address
+      proveSeconds := 0
+      peakTreeRssBytes := innerVerifyPeak
+    })
+  | .aggr =>
+    if item.shape? != some 0 then
+      return .error s!"shard {shardId}: wrap leaf requires shape 0"
+    let innerProofAdvice ← match ixvmSystem.proofToAdviceBytes
+        input.innerClaim input.proof with
+      | .error error =>
+        return .error s!"shard {shardId}: proof advice encoding failed: {error}"
+      | .ok bytes => pure bytes
+    let claimBytes := Ix.Claim.ser prepared.claim
+    let pubInput := Aggr.pubInput allowed claimBytes
+    IO.println s!"[aggregate-policy] proving slot {slotIdx}: wrap shard {shardId}"
+    (← IO.getStdout).flush
+    TracingTexray.resetPeakTreeRss
+    let (proved, proveSeconds) ← timed fun _ =>
+      aggrSystem.proveIxAggr aggrIdx pubInput 0
+        innerProofAdvice ByteArray.empty ixvmVk aggrVk
+        input.claimsBytes ByteArray.empty claimBytes allowed
+        (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[])
+    let provePeak ← TracingTexray.peakTreeRssBytes
+    let (outerClaim, proof) ← match proved with
+      | .error error => return .error s!"shard {shardId}: wrap proving failed: {error}"
+      | .ok result => pure result
+    if outerClaim != spec.outerClaim then
+      return .error s!"shard {shardId}: wrap produced an unexpected outer claim"
+    TracingTexray.resetPeakTreeRss
+    let (verified, verifySeconds) ← timed fun _ => aggrSystem.verify outerClaim proof
+    let verifyPeak ← TracingTexray.peakTreeRssBytes
+    match verified with
+    | .error error =>
+      return .error s!"shard {shardId}: wrap output verification failed: {error}"
+    | .ok () => pure ()
+    let address ← persistAggregateProof spec.statement proof
+    let proofBytes := proof.toBytes
+    let peak := max innerVerifyPeak (max provePeak verifyPeak)
+    let slot : AggregateSlot := {
+      kind := .aggr, statement := spec.statement,
+      subjectCount := spec.subjectCount, outerClaim,
+      proof, proofAddress? := some address,
+      claimsBytes := MultiStark.serializeClaims #[outerClaim]
+    }
+    pure (.ok {
+      slot
+      row := stageRow slotIdx item (some .ixvm) none proveSeconds verifySeconds
+        (some innerVerifySeconds) peak proofBytes.size
+        (Address.blake3 claimBytes) address
+      proveSeconds
+      peakTreeRssBytes := peak
+    })
+
+def runJoin (slotIdx : Nat) (item : ScheduledFold) (left right : AggregateSlot)
+    (spec : AggregateSlotSpec) (ixvmSystem aggrSystem : Aiur.AiurSystem)
+    (ixvmVk aggrVk allowed : ByteArray) (aggrIdx : Aiur.Bytecode.FunIdx) :
+    IO (Except String MeasuredSlot) := do
+  let output := spec.statement
+  let outputClaimBytes := Ix.Claim.ser output.claim
+  let pubInput := Aggr.pubInput allowed outputClaimBytes
+  let leftStatement := toAggrCheckEnvTrees left.statement
+  let rightStatement := toAggrCheckEnvTrees right.statement
+  let outputStatement := toAggrCheckEnvTrees output
+  let preimagesBlob := Aggr.preimagesBlob
+    #[Ix.Claim.ser left.statement.claim, Ix.Claim.ser right.statement.claim]
+  let trees := if item.structural then
+      Aggr.CheckEnvTrees.structuralAdviceTrees leftStatement rightStatement outputStatement
+    else Aggr.CheckEnvTrees.adviceTrees leftStatement rightStatement outputStatement
+  let treesBlob := Aggr.treesBlob trees
+  let pathsBlob := if item.structural then
+      Aggr.pathsBlob
+        (Aggr.CheckEnvTrees.structuralPathAdvice leftStatement rightStatement outputStatement)
+    else Aggr.pathsBlob #[]
+  let leftSystem := if left.kind == .ixvm then ixvmSystem else aggrSystem
+  let rightSystem := if right.kind == .ixvm then ixvmSystem else aggrSystem
+  let leftProofAdvice ← match leftSystem.proofToAdviceBytes left.outerClaim left.proof with
+    | .error error => return .error s!"slot {slotIdx}: left proof advice failed: {error}"
+    | .ok bytes => pure bytes
+  let rightProofAdvice ← match rightSystem.proofToAdviceBytes right.outerClaim right.proof with
+    | .error error => return .error s!"slot {slotIdx}: right proof advice failed: {error}"
+    | .ok bytes => pure bytes
+  let some shape := item.shape?
+    | return .error s!"slot {slotIdx}: join has no ix_aggr shape"
+  let mode := if item.structural then "structural" else "flat"
+  IO.println s!"[aggregate-policy] proving slot {slotIdx}: {mode} shape {shape}"
+  (← IO.getStdout).flush
+  TracingTexray.resetPeakTreeRss
+  let (proved, proveSeconds) ← timed fun _ =>
+    aggrSystem.proveIxAggr aggrIdx pubInput shape
+      leftProofAdvice rightProofAdvice ixvmVk aggrVk
+      left.claimsBytes right.claimsBytes outputClaimBytes allowed
+      preimagesBlob treesBlob pathsBlob
+  let provePeak ← TracingTexray.peakTreeRssBytes
+  let (outerClaim, proof) ← match proved with
+    | .error error => return .error s!"slot {slotIdx}: join proving failed: {error}"
+    | .ok result => pure result
+  if outerClaim != spec.outerClaim then
+    return .error s!"slot {slotIdx}: join produced an unexpected outer claim"
+  TracingTexray.resetPeakTreeRss
+  let (verified, verifySeconds) ← timed fun _ => aggrSystem.verify outerClaim proof
+  let verifyPeak ← TracingTexray.peakTreeRssBytes
+  match verified with
+  | .error error => return .error s!"slot {slotIdx}: output verification failed: {error}"
+  | .ok () => pure ()
+  let address ← persistAggregateProof output proof
+  let proofBytes := proof.toBytes
+  let peak := max provePeak verifyPeak
+  let slot : AggregateSlot := {
+    kind := .aggr, statement := output,
+    subjectCount := spec.subjectCount, outerClaim,
+    proof, proofAddress? := some address,
+    claimsBytes := MultiStark.serializeClaims #[outerClaim]
+  }
+  pure (.ok {
+    slot
+    row := stageRow slotIdx item (some left.kind) (some right.kind)
+      proveSeconds verifySeconds none peak proofBytes.size
+      (Address.blake3 outputClaimBytes) address
+    proveSeconds
+    peakTreeRssBytes := peak
+  })
+
+def commandOutput (cmd : String) (args : Array String := #[]) : IO String := do
+  try
+    let output ← IO.Process.output { cmd, args }
+    if output.exitCode == 0 then pure output.stdout.trimAscii.toString
+    else pure "unknown"
+  catch _ => pure "unknown"
+
+def cpuLabel : IO String := do
+  let output ← commandOutput "lscpu"
+  let model? := output.splitOn "\n" |>.find? (·.startsWith "Model name:")
+  pure <| model?.map (·.drop 11 |>.trimAscii.toString) |>.getD "unknown"
+
+def writeReport (path? : Option String) (metadata : Json) (plan stages : Array Json)
+    (status : String) (totals? : Option Json := none)
+    (error? : Option String := none) : IO Unit := do
+  if let some path := path? then
+    let fields : List (String × Json) :=
+      [("schema_version", Lean.toJson (1 : Nat)),
+       ("status", Json.str status),
+       ("metadata", metadata),
+       ("plan", Json.arr plan),
+       ("stages", Json.arr stages),
+       ("totals", totals?.getD Json.null)] ++
+      match error? with
+      | none => []
+      | some error => [("error", Json.str error)]
+    IO.FS.writeFile path ((Json.mkObj fields).pretty ++ "\n")
+
+def metadata (ixePath ixesPath : String) (ixeBytes ixesBytes : ByteArray)
+    (fixture : Fixture) (proofAddresses : Array String) (policy : Policy)
+    (queries structuralAbove jobs maxRamGiB : Nat)
+    (ixvmVk? aggrVk? : Option ByteArray := none) : IO Json := do
+  let commit ← commandOutput "git" #["rev-parse", "HEAD"]
+  let timestamp ← commandOutput "date" #["-Is"]
+  let host ← commandOutput "hostname"
+  let cpu ← cpuLabel
+  let memInfo ← try IO.FS.readFile "/proc/meminfo" catch _ => pure ""
+  let physicalRam := aggregateMemTotalBytes memInfo |>.getD 0
+  let fri := { Aiur.defaultFriParameters with numQueries := queries }
+  pure <| Json.mkObj
+    [("commit", Json.str commit),
+     ("timestamp", Json.str timestamp),
+     ("host", Json.str host),
+     ("cpu", Json.str cpu),
+     ("physical_ram_bytes", Lean.toJson physicalRam),
+     ("ixe", Json.str ixePath),
+     ("ixe_digest", Json.str (toString (Address.blake3 ixeBytes))),
+     ("ixe_bytes", Lean.toJson ixeBytes.size),
+     ("ixes", Json.str ixesPath),
+     ("ixes_digest", Json.str (toString (Address.blake3 ixesBytes))),
+     ("ixes_bytes", Lean.toJson ixesBytes.size),
+     ("shard_ids", Lean.toJson fixture.shardIds),
+     ("input_proof_addresses", Lean.toJson proofAddresses),
+     ("policy", Json.str policy.label),
+     ("recursion_parameters", Json.mkObj
+       [("log_blowup", Lean.toJson Aiur.defaultCommitmentParameters.logBlowup),
+        ("cap_height", Lean.toJson Aiur.defaultCommitmentParameters.capHeight),
+        ("log_final_poly_len", Lean.toJson fri.logFinalPolyLen),
+        ("max_log_arity", Lean.toJson fri.maxLogArity),
+        ("num_queries", Lean.toJson fri.numQueries),
+        ("commit_pow_bits", Lean.toJson fri.commitProofOfWorkBits),
+        ("query_pow_bits", Lean.toJson fri.queryProofOfWorkBits)]),
+     ("structural_above", Lean.toJson structuralAbove),
+     ("jobs", Lean.toJson jobs),
+     ("max_ram_gib", Lean.toJson maxRamGiB),
+     ("cache", Json.str "disabled"),
+     ("wall_scope", Json.str "input verification plus recursive slots"),
+     ("ixvm_vk_digest", ixvmVk?.map (Json.str ∘ toString ∘ Address.blake3)
+       |>.getD Json.null),
+     ("ix_aggr_vk_digest", aggrVk?.map (Json.str ∘ toString ∘ Address.blake3)
+       |>.getD Json.null)]
+
+def usage : String :=
+  "usage: bench-aggregate-policy --ixe ENV.ixe --ixes MANIFEST.ixes " ++
+  "--shards A,B,C,D --proof-A ADDR --proof-B ADDR --proof-C ADDR " ++
+  "--proof-D ADDR --policy wrap-first|direct [--structural-above N] " ++
+  "[--queries N] [--jobs 1] [--max-ram GIB] --no-cache --json RESULT.json " ++
+  "[--plan-only]"
+
+def main (args : List String) : IO UInt32 := do
+  if hasFlag args "--help" then
+    IO.println usage
+    return 0
+  let some ixePath := argStr args "--ixe" | do
+    IO.eprintln "error: --ixe is required"; IO.eprintln usage; return 2
+  let some ixesPath := argStr args "--ixes" | do
+    IO.eprintln "error: --ixes is required"; IO.eprintln usage; return 2
+  let some shardsValue := argStr args "--shards" | do
+    IO.eprintln "error: --shards is required"; IO.eprintln usage; return 2
+  let shardIds ← match parseShardIds shardsValue with
+    | .error error => IO.eprintln s!"error: {error}"; return 2
+    | .ok ids => pure ids
+  let some policyValue := argStr args "--policy" | do
+    IO.eprintln "error: --policy is required"; IO.eprintln usage; return 2
+  let policy ← match Policy.parse policyValue with
+    | .error error => IO.eprintln s!"error: {error}"; return 2
+    | .ok policy => pure policy
+  let queries := (argNat? args "--queries").getD 100
+  if queries != 100 then
+    IO.eprintln "error: M1-f requires --queries 100 so roots use the production verifier parameters"
+    return 2
+  let structuralAbove := (argNat? args "--structural-above").getD defaultStructuralAbove
+  let jobs := (argNat? args "--jobs").getD 1
+  if jobs != 1 then
+    IO.eprintln "error: the M1-f policy comparison requires --jobs 1"; return 2
+  let maxRamGiB := (argNat? args "--max-ram").getD 450
+  if maxRamGiB == 0 then
+    IO.eprintln "error: --max-ram must be positive"; return 2
+  let planOnly := hasFlag args "--plan-only"
+  let jsonPath? := argStr args "--json"
+  if !planOnly && jsonPath?.isNone then
+    IO.eprintln "error: measured runs require --json"; return 2
+  if !planOnly && !hasFlag args "--no-cache" then
+    IO.eprintln "error: measured runs require --no-cache"; return 2
+
+  let ixeBytes ← IO.FS.readBinFile ixePath
+  let ixesBytes ← IO.FS.readBinFile ixesPath
+  let env ← match Ixon.deEnvAnon ixeBytes with
+    | .error error => IO.eprintln s!"deserialize {ixePath} failed: {error}"; return 1
+    | .ok env => pure env
+  let rawView ← match Ix.Cli.CheckCmd.parseIxesManifest ixesBytes with
+    | .error error => IO.eprintln s!"manifest parse failed: {error}"; return 1
+    | .ok view => pure view
+  if !(← Ix.Cli.CheckCmd.shardsCover env rawView.shards) then return 1
+  let (view, counts) ← match rawView.pruneEmpty env with
+    | .error error => IO.eprintln error; return 1
+    | .ok result => pure result
+  let fixture ← match selectFixture env view counts shardIds with
+    | .error error => IO.eprintln s!"select fixture: {error}"; return 1
+    | .ok fixture => pure fixture
+  let plan ← match schedulePlan fixture.tree.foldPlan fixture.subjectCounts
+      structuralAbove policy.directJoins with
+    | .error error => IO.eprintln s!"schedule selected fixture: {error}"; return 1
+    | .ok plan => pure plan
+  let expected ← match expectedStatements plan fixture.prepared with
+    | .error error => IO.eprintln s!"reconstruct selected root: {error}"; return 1
+    | .ok statements => pure statements
+  let some expectedRoot := expected.back? | do
+    IO.eprintln "selected fixture produced no host root"; return 1
+  let rows := planRows plan fixture.shardIds
+  printPlan policy plan fixture.shardIds structuralAbove
+  let weights := aggregateSlotRamWeights plan
+  let requiredRam := weights.foldl max 0
+  if maxRamGiB * aggregateGiB < requiredRam then
+    IO.eprintln s!"error: --max-ram {maxRamGiB} GiB is below the plan's largest \
+      slot reserve of {requiredRam / aggregateGiB} GiB"
+    return 2
+
+  let mut proofHexes : Array String := #[]
+  if !planOnly then
+    for shardId in fixture.shardIds do
+      let flag := s!"--proof-{shardId}"
+      let some proofHex := argStr args flag | do
+        IO.eprintln s!"error: {flag} is required"; return 2
+      proofHexes := proofHexes.push proofHex
+  let metadata0 ← metadata ixePath ixesPath ixeBytes ixesBytes fixture proofHexes
+    policy queries structuralAbove jobs maxRamGiB
+  if planOnly then
+    writeReport jsonPath? metadata0 rows #[] "plan-only"
+    return 0
+
+  writeReport jsonPath? metadata0 rows #[] "preparing"
+  TracingTexray.startSampler 25
+  IO.println "[aggregate-policy] compiling IxVM and ixAggr systems"
+  let ixvmCompiled ← match ← compileToplevel "IxVM" IxVM.ixVM with
+    | .error error =>
+      writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+      IO.eprintln error
+      return 1
+    | .ok compiled => pure compiled
+  let aggrCompiled ← match ← compileToplevel "ixAggr recursion" Aggr.ixAggr with
+    | .error error =>
+      writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+      IO.eprintln error
+      return 1
+    | .ok compiled => pure compiled
+  let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get!
+  let aggrIdx := aggrCompiled.getFuncIdx `ix_aggr |>.get!
+  let friParameters := { Aiur.defaultFriParameters with numQueries := queries }
+  let recursionParameters : MultiStark.RecursionParameters := {
+    commitment := Aiur.defaultCommitmentParameters
+    fri := friParameters
+  }
+  let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode
+    Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
+  let aggrSystem := MultiStark.buildRecursionSystem aggrCompiled.bytecode
+    recursionParameters
+  let ixvmVk := ixvmSystem.vkBytes
+  let aggrVk := aggrSystem.vkBytes
+  let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx
+  let specs ← match buildAggrSlotSpecs plan fixture.prepared aggrVk allowed
+      verifyIdx aggrIdx recursionParameters with
+    | .error error =>
+      let error := s!"prepare policy slots: {error}"
+      writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+      IO.eprintln error
+      return 1
+    | .ok specs => pure specs
+  let some rootSpec := specs.back? | do
+    let error := "prepared policy has no root slot"
+    writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+    IO.eprintln error
+    return 1
+  if rootSpec.statement.claim != expectedRoot.claim then
+    let error := "prepared root differs from independent selected-subtree fold"
+    writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+    IO.eprintln error
+    return 1
+
+  let mut inputs : Array InputProof := #[]
+  for shard in [:fixture.shardIds.size] do
+    let shardId := fixture.shardIds[shard]!
+    let some preparedShard := fixture.prepared[shard]? | do
+      let error := s!"internal: missing prepared shard {shardId}"
+      writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+      IO.eprintln error
+      return 1
+    let input ← match ← loadInputProof shardId proofHexes[shard]!
+        preparedShard verifyIdx with
+      | .error error =>
+        writeReport jsonPath? metadata0 rows #[] "error" (error? := some error)
+        IO.eprintln error
+        return 1
+      | .ok input => pure input
+    inputs := inputs.push input
+  let metadata ← metadata ixePath ixesPath ixeBytes ixesBytes fixture proofHexes
+    policy queries structuralAbove jobs maxRamGiB (some ixvmVk) (some aggrVk)
+  let mut stages : Array Json := #[]
+  writeReport jsonPath? metadata rows stages "running"
+  let wallStarted ← IO.monoNanosNow
+  let mut slots : Array AggregateSlot := #[]
+  let mut proveSeconds : Float := 0
+  let mut maxPeak : Nat := 0
+  for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do
+    let some spec := specs[slotIdx]? | do
+      let error := s!"missing prepared slot {slotIdx}"
+      writeReport jsonPath? metadata rows stages "error" (error? := some error)
+      IO.eprintln error
+      return 1
+    let measured ← match item.op with
+      | .leaf shard =>
+        let shardId := fixture.shardIds[shard]!
+        let some preparedShard := fixture.prepared[shard]? | do
+          let error := s!"slot {slotIdx}: missing prepared shard {shardId}"
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        let some input := inputs[shard]? | do
+          let error := s!"slot {slotIdx}: missing input proof for shard {shardId}"
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        match ← runLeaf slotIdx shardId item preparedShard
+            input spec ixvmSystem aggrSystem ixvmVk aggrVk allowed aggrIdx with
+        | .error error =>
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        | .ok measured => pure measured
+      | .join leftIdx rightIdx =>
+        let some left := slots[leftIdx]? | do
+          let error := s!"slot {slotIdx}: missing left slot {leftIdx}"
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        let some right := slots[rightIdx]? | do
+          let error := s!"slot {slotIdx}: missing right slot {rightIdx}"
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        match ← runJoin slotIdx item left right spec ixvmSystem aggrSystem
+            ixvmVk aggrVk allowed aggrIdx with
+        | .error error =>
+          writeReport jsonPath? metadata rows stages "error" (error? := some error)
+          IO.eprintln error
+          return 1
+        | .ok measured => pure measured
+    slots := slots.push measured.slot
+    stages := stages.push measured.row
+    proveSeconds := proveSeconds + measured.proveSeconds
+    maxPeak := max maxPeak measured.peakTreeRssBytes
+    writeReport jsonPath? metadata rows stages "running"
+
+  let wallEnded ← IO.monoNanosNow
+  let wallSeconds := (wallEnded - wallStarted).toFloat / 1e9
+  let some root := slots.back? | do
+    let error := "policy plan produced no root slot"
+    writeReport jsonPath? metadata rows stages "error" (error? := some error)
+    IO.eprintln error
+    return 1
+  if root.kind != .aggr || root.statement.claim != expectedRoot.claim then
+    let error := "proved root differs from the independently reconstructed ix_aggr root"
+    writeReport jsonPath? metadata rows stages "error" (error? := some error)
+    IO.eprintln error
+    return 1
+  let some rootAddress := root.proofAddress? | do
+    let error := "root aggregate proof was not persisted"
+    writeReport jsonPath? metadata rows stages "error" (error? := some error)
+    IO.eprintln error
+    return 1
+  let rootProofBytes := root.proof.toBytes
+  let rootClaimDigest := Address.blake3 (Ix.Claim.ser root.statement.claim)
+  let outerClaimDigest := Address.blake3 (MultiStark.serializeClaims #[root.outerClaim])
+  let totals := Json.mkObj
+    [("wall_seconds", jsonRound 6 wallSeconds),
+     ("serialized_prove_seconds", jsonRound 6 proveSeconds),
+     ("peak_tree_rss_bytes", Lean.toJson maxPeak),
+     ("root_claim_digest", Json.str (toString rootClaimDigest)),
+     ("root_outer_claim_digest", Json.str (toString outerClaimDigest)),
+     ("root_proof_bytes", Lean.toJson rootProofBytes.size),
+     ("root_proof_address", Json.str (toString rootAddress)),
+     ("retains_assumptions", Lean.toJson root.statement.assumptions.isSome)]
+  writeReport jsonPath? metadata rows stages "ok" (some totals)
+  IO.println s!"[aggregate-policy] OK: {policy.label}; {proveSeconds}s proving; \
+    {wallSeconds}s measured wall; peak {maxPeak} bytes; root {rootAddress} \
+    ({rootProofBytes.size} bytes, claim {rootClaimDigest})"
+  pure 0
+
+end Benchmarks.AggregatePolicy
+
+def main (args : List String) : IO UInt32 :=
+  Benchmarks.AggregatePolicy.main args
diff --git a/Benchmarks/Compile/lake-manifest.json b/Benchmarks/Compile/lake-manifest.json
index 5ffda5058..74b77d83a 100644
--- a/Benchmarks/Compile/lake-manifest.json
+++ b/Benchmarks/Compile/lake-manifest.json
@@ -182,10 +182,10 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "db25a8a21579d8211eec4347402721f5674bf2c1",
+   "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "db25a8a21579d8211eec4347402721f5674bf2c1",
+   "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "inherited": true,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
diff --git a/Benchmarks/RecursionDebug.lean b/Benchmarks/RecursionDebug.lean
index 41167de24..1a16e62bf 100644
--- a/Benchmarks/RecursionDebug.lean
+++ b/Benchmarks/RecursionDebug.lean
@@ -102,19 +102,24 @@ def proveConst (ixePath constName : String) (skipDeps : Bool)
       match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash with
       | .error e => IO.eprintln s!"proveAddrWithEnv failed: {e}"; return none
       | .ok (claimBytes, proof, _) =>
-        -- `verify_claim`'s public input is the 32-G blake3 digest of the
-        -- serialized `Ix.Claim` (same recipe as `ix verify` / bench-typecheck).
+        -- `verify_claim`'s public input is the packed blake3 digest of the
+        -- serialized `Ix.Claim` (same recipe as `ix verify` / bench-typecheck:
+        -- 8 G elements of 4 LE bytes each, `ClaimHarness.packedDigestKey`).
         let digest := Address.blake3 claimBytes
-        pure (Aiur.buildClaim funIdx (digest.hash.data.map .ofUInt8) #[], proof)
+        pure (Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[], proof)
   let t1 ← IO.monoNanosNow
-  let proofBytes := proof.toBytes
-  IO.println s!"inner prove: {secs t0 t1} s, proof {proofBytes.size} bytes"
+  IO.println s!"inner prove: {secs t0 t1} s, proof {proof.toBytes.size} bytes"
   -- Sanity: the inner proof must verify out-of-circuit before we chase the
   -- recursive verifier.
   match aiurSystem.verify claim proof with
   | .ok () => IO.println "inner proof verifies out-of-circuit: ok"
   | .error e => IO.eprintln s!"⚠ inner proof FAILS out-of-circuit verify: {e}"
-  return some (proofBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim])
+  -- The in-circuit verifier consumes the per-query advice transport, not
+  -- the pruned-multiproof wire format.
+  match aiurSystem.proofToAdviceBytes claim proof with
+  | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return none
+  | .ok adviceBytes =>
+    return some (adviceBytes, aiurSystem.vkBytes, MultiStark.serializeClaims #[claim])
 
 def main (args : List String) : IO UInt32 := do
   let ixePath := (argStr args "--ixe").getD "init.ixe"
@@ -126,6 +131,9 @@ def main (args : List String) : IO UInt32 := do
   let mode := (argStr args "--mode").getD "native"
   let skipDeps := args.contains "--skip-deps"
   let fri := friParams (argNat args "--queries" 100)
+  if fri.numQueries == 0 then
+    IO.eprintln "error: --queries must be positive"
+    return 1
   let depth := argNat args "--depth" 2
   let stackLimit := argNat args "--stack" 40
   IO.FS.createDirAll dir
diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean
index 177905eae..c20e69d9c 100644
--- a/Benchmarks/Typecheck.lean
+++ b/Benchmarks/Typecheck.lean
@@ -1,10 +1,12 @@
 import Cli
 import Ix.IxVM
 import Ix.IxVM.Toplevel
+import Ix.IxVM.ClaimHarness
 import Ix.Aiur.Protocol
 import Ix.Aiur.Compiler
 import Ix.Aiur.Statistics
 import Ix.MultiStark
+import Ix.Aggr
 import Ix.TracingTexray
 import Ix.Benchmark.Bench
 import Ix.Benchmark.Results
@@ -42,8 +44,9 @@ lake exe bench-typecheck --ixe <path> --consts <n1,n2,…> [--consts-file <p>] [
                  deps) instead of its whole transitive closure (verify_claim,
                  the default). Same flag as `zisk-host --skip-deps`; reserved
                  for targets too expensive to full-closure-check.
-  --json <path>  write per-constant results JSON to <path>. Off by default:
-                 normal CLI usage prints only the human-readable summary.
+  --json <path>  write results JSON to <path> (per constant, plus one pair row
+                 with --join). Off by default: normal CLI usage prints only
+                 the human-readable summary.
   --texray       enable the tracing-texray timeline + RAM breakdown. With
                  --json <path>, per-phase span timings are also written to
                  <path>.spans (JSON Lines) for the CI drill-down. Off by default.
@@ -71,10 +74,19 @@ lake exe bench-typecheck --ixe <path> --consts <n1,n2,…> [--consts-file <p>] [
                  proves stream the same `stark/...` span names, so the summed
                  `phase-stark-*` fields cover the pair. Conflicts with
                  --execute-only.
+  --join         with --recursive and exactly two constants, benchmark the
+                 converged ix_aggr direct flat pair (shape 2) over the two
+                 singleton-CheckEnv IxVM proofs. Emits one `left + right` JSON row
+                 carrying join-execute-time, join-fft-cost, join-prove-time,
+                 join-peak-rss, join-proof-size, and join-verify-time. This is
+                 an explicit W0/Section-13 diagnostic, not part of the default
+                 per-constant CI run.
 ```
 
-For each constant the harness STARK-checks `Ix.Claim.check addr none` (the full
-transitive typecheck) in two phases:
+By default, the harness STARK-checks `Ix.Claim.check addr none` for each
+constant (the full transitive typecheck). `--join` instead uses a singleton
+`CheckEnv` shard claim for each of its two children. Work proceeds in up to
+four phases:
 
 1. **Execute** (every constant): run the bytecode out-of-circuit. Cheap and
    deterministic, so we always record `constants` (the number of constants the
@@ -91,6 +103,11 @@ transitive typecheck) in two phases:
 3. **Recursive** (`--recursive` only, right after each constant's prove): feed
    the fresh proof + vk + claims to `verify_multi_stark_proof`, execute it,
    then prove the verifier execution — the end-to-end recursion cost.
+4. **Join** (`--recursive --join`, exactly two constants): use each requested
+   constant as a one-owned-constant `CheckEnv` shard, then execute/prove/verify
+   the converged `ix_aggr` direct flat pair (shape 2) over those IxVM proofs.
+   The pair gets a dedicated JSON row because the join is one shared operation,
+   not a cost attributable to either child independently.
 
 When `--json` is set the file is rewritten after every prove, so an external
 `timeout` still leaves a complete file of the results collected so far (cheapest
@@ -110,6 +127,10 @@ KZG stages land), plus the pipeline ledger `"total-time"`, `"pipeline-throughput
 and throughput are scoped to that stage's own prove window. Any
 bencher-specific reshaping is the caller's job (see
 `.github/workflows/bench-main.yml`).
+
+With `--join`, the same object also contains one `"left + right"` row. It has
+`status`, the sum of the two child `constants`, and the six `join-*` measures;
+it intentionally has no per-child or pipeline ledger fields.
 -/
 
 open Lean (Json Name)
@@ -204,6 +225,34 @@ structure Result where
   recursiveVerifySec : Option Float := none
   deriving Inhabited
 
+/-- The successfully verified IxVM artifact retained for the optional binary
+    join phase. `innerClaimsBytes` is the serialized singleton list containing
+    the IxVM proof's Aiur claim; `checkEnvClaimBytes` is the nested Ix claim
+    preimage that the converged join opens below it. -/
+structure JoinArtifact where
+  label : String
+  constants : Nat
+  statement : MultiStark.CheckEnvTrees
+  innerClaimsBytes : ByteArray
+  checkEnvClaimBytes : ByteArray
+  outerClaim : Array Aiur.G
+  proof : Aiur.Proof
+
+/-- Measurements for the one pair-wide `ix_aggr` shape-2 operation. Kept separate
+    from `Result`: copying these fields onto both child rows would count the
+    same join twice, while attaching them to one child would make the result
+    order-dependent. -/
+structure JoinResult where
+  name : String
+  constants : Nat
+  fftCost : Float
+  executeSec : Float
+  proveSec : Float
+  peakRss : Nat
+  proofSize : Nat
+  verifySec : Option Float
+  failed : Bool := false
+
 /-- A `Json` number with at most `d` decimal places, rendered decimally.
     `Float`'s own `ToJson` prints the full binary representation
     (`0.02602000000000000146…`), so build the `JsonNumber` (mantissa ·
@@ -216,6 +265,23 @@ def jsonRound (d : Nat) (f : Float) : Json :=
     else Int.ofNat scaled.round.toUInt64.toNat
   Json.num ⟨m, d⟩
 
+def JoinResult.toJsonEntry (r : JoinResult) : String × Json :=
+  if r.failed then
+    (r.name, Json.mkObj [("status", Json.str "rejected")])
+  else
+    let fields : List (String × Json) :=
+      [ ("status", Json.str "ok")
+      , ("constants", Lean.toJson r.constants)
+      , ("join-fft-cost", jsonRound 0 r.fftCost)
+      , ("join-execute-time", jsonRound 6 r.executeSec)
+      , ("join-prove-time", jsonRound 6 r.proveSec)
+      , ("join-peak-rss", Lean.toJson r.peakRss)
+      , ("join-proof-size", Lean.toJson r.proofSize) ]
+    let fields := match r.verifySec with
+      | some seconds => fields ++ [("join-verify-time", jsonRound 6 seconds)]
+      | none => fields
+    (r.name, Json.mkObj fields)
+
 /-- Flat results object: `name → { constants, … }`. No bencher-specific
     shaping.
 
@@ -333,6 +399,10 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
     IO.eprintln "error: provide at least one constant via --consts <n1,n2,…> and/or --consts-file <path>"
     return 1
   let jsonOut : Option String := (p.flag? "json").map (·.as! String)
+  let queryCount? := (p.flag? "queries").map (·.as! Nat)
+  if queryCount? == some 0 then
+    IO.eprintln "error: --queries must be positive"
+    return Ix.Benchmark.Results.exitUsage
   -- skip-deps: check just the target (`verify_const`, trusting its deps)
   -- instead of re-checking the whole transitive closure (`verify_claim`).
   let skipDeps := p.hasFlag "skip-deps"
@@ -342,12 +412,24 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   -- Recursive: after each constant's prove, execute AND prove the in-circuit
   -- multi-stark verifier over the fresh proof (Phase 3).
   let recursive := p.hasFlag "recursive"
+  -- Join: retain exactly two successful recursive lifts, then benchmark one
+  -- production flat join over their singleton-CheckEnv statements.
+  let join := p.hasFlag "join"
   if recursive && executeOnly then
     IO.eprintln "error: --recursive measures the prove path; drop --execute-only"
     return Ix.Benchmark.Results.exitUsage
+  if join && !recursive then
+    IO.eprintln "error: --join requires --recursive"
+    return Ix.Benchmark.Results.exitUsage
+  if join && skipDeps then
+    IO.eprintln "error: --join requires singleton CheckEnv shards; drop --skip-deps"
+    return Ix.Benchmark.Results.exitUsage
   -- Off by default; CI passes --texray explicitly.
   let useTexray := p.hasFlag "texray"
   let useInterp := p.hasFlag "interp"
+  if join && useInterp then
+    IO.eprintln "error: --join requires the native singleton-shard prover; drop --interp"
+    return Ix.Benchmark.Results.exitUsage
   -- Start the process-tree RSS sampler so each Result's peak-rss reflects the
   -- true high-water mark. With --texray, install the streaming subscriber up
   -- front: every phase span — aiur/execute_ixvm in Phase 1 included —
@@ -386,7 +468,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   -- `--queries N` overrides the selected parameter set's FRI query count
   -- (inner and outer proof alike in --recursive mode, which builds both
   -- systems from `friParams`).
-  let friParams := match (p.flag? "queries").map (·.as! Nat) with
+  let friParams := match queryCount? with
     | some n => { friParams with numQueries := n }
     | none => friParams
   let aiurSystem := Aiur.AiurSystem.build compiled.bytecode commitParams friParams
@@ -403,6 +485,20 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
         | throw (IO.userError "verify_multi_stark_proof entrypoint missing")
       pure (some (vCompiled, vIdx,
         Aiur.AiurSystem.build vCompiled.bytecode commitParams friParams))
+  -- The opt-in pair metric uses the converged production aggregator while the
+  -- generic recursive phase above remains the standalone Multi-STARK verifier
+  -- benchmark. Compile the second system only when `--join` requests it.
+  let aggrCtx : Option
+      (Aiur.CompiledToplevel × Aiur.Bytecode.FunIdx × Aiur.AiurSystem) ←
+    if !join then pure none else do
+      let .ok aggrTop := Aggr.ixAggr
+        | throw (IO.userError "Merging ix_aggr failed")
+      let .ok aggrCompiled := aggrTop.compile
+        | throw (IO.userError "Compilation of ix_aggr failed")
+      let some aggrIdx := aggrCompiled.getFuncIdx `ix_aggr
+        | throw (IO.userError "ix_aggr entrypoint missing")
+      pure (some (aggrCompiled, aggrIdx,
+        Aiur.AiurSystem.build aggrCompiled.bytecode commitParams friParams))
 
   -- Load the serialized env lazily (the `ix check --ixe` path, #445): byte-window
   -- constants over the backing buffer, so only the checked closure is ever
@@ -419,6 +515,9 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   if targets.isEmpty then
     IO.eprintln "no requested constants were found in the env"
     return 1
+  if join && targets.size != 2 then
+    IO.eprintln s!"error: --join requires exactly two resolved constants; got {targets.size}"
+    return Ix.Benchmark.Results.exitUsage
 
   -- Build the env once into a Rust-owned `EnvHandle` and share it
   -- across both Phase 1 and Phase 2 loops. Per-target FFI calls
@@ -427,6 +526,8 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
     | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1
     | .ok h => pure h
 
+  let singletonOwnedBlob (addr : Address) : ByteArray := addr.hash
+
   -- Phase 1: execute every constant (cheap, deterministic structural metrics).
   -- For full-closure check claims, use `checkAddrWithEnv` against the
   -- shared `envHandle`. For `--skip-deps` (`buildVerifyConst`), the
@@ -455,6 +556,9 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer
           else
             compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer
+        else if join then
+          compiled.bytecode.shardCheckWithEnv funIdx envHandle
+            (singletonOwnedBlob addr) useInterp
         else
           compiled.bytecode.checkAddrWithEnv funIdx envHandle addr.hash useInterp
       let execPeak ← TracingTexray.peakTreeRssBytes
@@ -506,6 +610,17 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
         let (name, row) := Result.toJsonEntry executeOnly r
         Ix.Benchmark.Results.writeEntry path name row
     | none => pure ()
+  let writeJoinJson (result : JoinResult) : IO Unit :=
+    match jsonOut with
+    | some path =>
+      let (name, row) := result.toJsonEntry
+      Ix.Benchmark.Results.writeEntry path name row
+    | none => pure ()
+  let writeRejectedJoin (name : String) : IO Unit :=
+    match jsonOut with
+    | some path => Ix.Benchmark.Results.writeEntry path name <|
+        Json.mkObj [("status", Json.str "rejected")]
+    | none => pure ()
 
   -- `--execute-only`: stop after Phase 1; the results JSON (if requested) is
   -- already complete with the execute metrics.
@@ -523,6 +638,7 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
   let mut ordered := execed.qsort (·.1.fftCost < ·.1.fftCost)
   writeJson (ordered.map (·.1))
   let mut spent : Float := 0.0
+  let mut joinArtifacts : Array JoinArtifact := #[]
   for i in [:ordered.size] do
     let (r, addr) := ordered[i]!
     if r.failed then continue
@@ -537,10 +653,22 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
       let (proveRes, proveSec) ← timed fun _ =>
         if skipDeps then
           let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr
-          if useInterp then
-            aiurSystem.prove funIdx witness.input witness.inputIOBuffer
-          else
-            aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer
+          let proveRes :=
+            if useInterp then
+              aiurSystem.prove funIdx witness.input witness.inputIOBuffer
+            else
+              aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer
+          proveRes.map fun (claim, proof, ioBuf) =>
+            (claim, proof, ioBuf, (none : Option ByteArray))
+        else if join then
+          match aiurSystem.shardProveWithEnv funIdx envHandle
+              (singletonOwnedBlob addr) with
+          | .error e => .error e
+          | .ok (claimBytes, proof, ioBuf) =>
+            let digest := Address.blake3 claimBytes
+            let claim :=
+              Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[]
+            .ok (claim, proof, ioBuf, some claimBytes)
         else
           match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash useInterp with
           | .error e => .error e
@@ -552,10 +680,11 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             let digest := Address.blake3 claimBytes
             let claim :=
               Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[]
-            .ok (claim, proof, ioBuf)
-      match (proveRes : Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) with
+            .ok (claim, proof, ioBuf, none)
+      match (proveRes : Except String
+          (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer × Option ByteArray)) with
       | .error e => IO.eprintln s!"  prove {r.name} failed: {e}"; continue
-      | .ok (claim, proof, _ioBuf) =>
+      | .ok (claim, proof, _ioBuf, checkEnvClaimBytes?) =>
         spent := spent + proveSec
         let peak ← TracingTexray.peakTreeRssBytes
         let proofBytes := Aiur.Proof.toBytes proof
@@ -589,14 +718,22 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
         if let some (vCompiled, vIdx, vSystem) := vCtx then
           IO.println s!"  [{i + 1}/{ordered.size}] recursively verifying {r.name} …"
           (← IO.getStdout).flush
-          let claimBytes := MultiStark.serializeClaims #[claim]
+          let innerClaimsBytes := MultiStark.serializeClaims #[claim]
           let vkBytes := aiurSystem.vkBytes
-          let pubInput := MultiStark.verifierPubInput vkBytes claimBytes
+          let pubInput := MultiStark.verifierPubInput vkBytes innerClaimsBytes
+          -- The in-circuit verifier consumes the per-query advice transport;
+          -- `proofBytes` (the pruned-multiproof wire format) stays the
+          -- reported proof size but is not parseable in-circuit.
+          let adviceBytes ← match aiurSystem.proofToAdviceBytes claim proof with
+            | .ok bytes => pure bytes
+            | .error e =>
+              IO.eprintln s!"  ❌ advice re-encoding for {r.name} FAILED: {e}"
+              continue
           -- Native path: the advice buffer is built in Rust from the raw
           -- byte blobs and execution routes through the codegen'd verifier.
           let (rvRes, rvSec) ← timed fun _ =>
-            vCompiled.bytecode.executeMultiStark vIdx pubInput proofBytes
-              vkBytes claimBytes useInterp
+            vCompiled.bytecode.executeMultiStark vIdx pubInput adviceBytes
+              vkBytes innerClaimsBytes useInterp
           match rvRes with
           | .error e =>
             IO.eprintln s!"  ❌ recursive verifier REJECTED {r.name}'s proof: {e}"
@@ -621,8 +758,8 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
             (← IO.getStdout).flush
             TracingTexray.resetPeakTreeRss
             let (rvProveRes, rvProveSec) ← timed fun _ =>
-              vSystem.proveMultiStark vIdx pubInput proofBytes vkBytes
-                claimBytes useInterp
+              vSystem.proveMultiStark vIdx pubInput adviceBytes vkBytes
+                innerClaimsBytes useInterp
             let (rvClaim, rvProof) ← match rvProveRes with
               | .ok result => pure result
               | .error e =>
@@ -646,13 +783,154 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do
                         , recursiveProofSize := some rvProofBytes.size
                         , recursiveVerifySec := rvVerifySec? }, addr)
             writeJson (ordered.map (·.1))
+            if join && !r.failed then
+              match rvVerifyRes, checkEnvClaimBytes? with
+              | .ok (), some checkEnvClaimBytes =>
+                let (expectedClaim, trees) ← IO.ofExcept <|
+                  IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv #[addr]
+                if Ix.Claim.ser expectedClaim != checkEnvClaimBytes then
+                  throw <| IO.userError s!"join benchmark: native shard claim for \
+                    {r.name} differs from host reconstruction"
+                let statement ← IO.ofExcept <|
+                  MultiStark.CheckEnvTrees.ofClaim expectedClaim trees
+                joinArtifacts := joinArtifacts.push {
+                  label := r.name
+                  constants := r.constants
+                  statement
+                  innerClaimsBytes
+                  checkEnvClaimBytes
+                  outerClaim := claim
+                  proof := proof
+                }
+              | .error _, _ => pure ()
+              | .ok (), none =>
+                throw <| IO.userError s!"join benchmark: missing CheckEnv claim \
+                  preimage for {r.name}"
     catch e =>
       IO.eprintln s!"  prove {r.name} threw: {e}"
 
+  -- Phase 4 (--recursive --join): one pair-wide converged direct join. The two
+  -- child rows retain their ordinary IxVM/recursive-verifier measurements;
+  -- the shared ix_aggr shape-2 proof lands under its own stable `left + right`
+  -- row so it is neither duplicated nor assigned arbitrarily to one child.
+  let mut joinRejected := false
+  if join then
+    IO.println "── Phase 4: ix_aggr direct flat pair (shape 2) ──"
+    let leftLabel := targets[0]!.1
+    let rightLabel := targets[1]!.1
+    let pairName := s!"{leftLabel} + {rightLabel}"
+    let some left := joinArtifacts.find? fun artifact => artifact.label == leftLabel | do
+      IO.eprintln s!"join benchmark: no verified IxVM proof for {leftLabel}"
+      return 1
+    let some right := joinArtifacts.find? fun artifact => artifact.label == rightLabel | do
+      IO.eprintln s!"join benchmark: no verified IxVM proof for {rightLabel}"
+      return 1
+    let some (aggrCompiled, aggrIdx, aggrSystem) := aggrCtx | do
+      IO.eprintln "join benchmark: ix_aggr context was not built"
+      return 1
+    let ixvmVk := aiurSystem.vkBytes
+    let aggrVk := aggrSystem.vkBytes
+    let allowed := Aggr.allowedBlob ixvmVk funIdx aggrVk aggrIdx
+    let leftStatement : Aggr.CheckEnvTrees := {
+      subjects := left.statement.subjects
+      assumptions := left.statement.assumptions
+    }
+    let rightStatement : Aggr.CheckEnvTrees := {
+      subjects := right.statement.subjects
+      assumptions := right.statement.assumptions
+    }
+    let outputStatement := leftStatement.join rightStatement
+    let outputClaimBytes := Ix.Claim.ser outputStatement.claim
+    let pubInput := Aggr.pubInput allowed outputClaimBytes
+    let preimagesBlob := Aggr.preimagesBlob
+      #[left.checkEnvClaimBytes, right.checkEnvClaimBytes]
+    let treesBlob := Aggr.treesBlob <|
+      Aggr.CheckEnvTrees.adviceTrees leftStatement rightStatement outputStatement
+    let pathsBlob := Aggr.pathsBlob #[]
+    let leftProofAdvice ← match aiurSystem.proofToAdviceBytes
+        left.outerClaim left.proof with
+      | .error e =>
+        IO.eprintln s!"join benchmark: left proof advice encoding failed: {e}"
+        return 1
+      | .ok bytes => pure bytes
+    let rightProofAdvice ← match aiurSystem.proofToAdviceBytes
+        right.outerClaim right.proof with
+      | .error e =>
+        IO.eprintln s!"join benchmark: right proof advice encoding failed: {e}"
+        return 1
+      | .ok bytes => pure bytes
+    let shape := Aggr.shapeCode (.ixvm, some .ixvm)
+    IO.println s!"  executing join {pairName} …"
+    (← IO.getStdout).flush
+    let (joinExecuteResult, joinExecuteSec) ← timed fun _ =>
+      aggrCompiled.bytecode.executeIxAggr aggrIdx pubInput shape
+        leftProofAdvice rightProofAdvice ixvmVk aggrVk
+        left.innerClaimsBytes right.innerClaimsBytes outputClaimBytes allowed
+        preimagesBlob treesBlob pathsBlob
+    let joinFftCost ← match joinExecuteResult with
+      | .error e =>
+        IO.eprintln s!"  ❌ ix_aggr direct join REJECTED {pairName}: {e}"
+        writeRejectedJoin pairName
+        joinRejected := true
+        pure none
+      | .ok (_, queryCounts) =>
+        let stats := Aiur.computeStats aggrCompiled queryCounts aggrSystem.circuitShapes
+          (logBlowup := commitParams.logBlowup)
+        IO.println s!"  {pairName}: join-execute={joinExecuteSec}s \
+          join-fft-cost={stats.totalFftCost}"
+        if useTexray then Aiur.printStats stats
+        pure (some stats.totalFftCost)
+    if let some joinFftCost := joinFftCost then
+      IO.println s!"  proving join {pairName} …"
+      (← IO.getStdout).flush
+      TracingTexray.resetPeakTreeRss
+      let (joinProveResult, joinProveSec) ← timed fun _ =>
+        aggrSystem.proveIxAggr aggrIdx pubInput shape
+          leftProofAdvice rightProofAdvice ixvmVk aggrVk
+          left.innerClaimsBytes right.innerClaimsBytes outputClaimBytes allowed
+          preimagesBlob treesBlob pathsBlob
+      match joinProveResult with
+      | .error e =>
+        IO.eprintln s!"  prove join {pairName} failed: {e}"
+        return 1
+      | .ok (joinClaim, joinProof) =>
+        let expectedClaim := Aiur.buildClaim aggrIdx pubInput #[]
+        if joinClaim != expectedClaim then
+          IO.eprintln s!"  join {pairName} returned an unexpected outer claim"
+          return 1
+        let joinPeak ← TracingTexray.peakTreeRssBytes
+        let joinProofBytes := joinProof.toBytes
+        let (joinVerifyResult, joinVerifySec) ← timed fun _ =>
+          aggrSystem.verify joinClaim joinProof
+        let joinVerifySec? ← match joinVerifyResult with
+          | .ok () => pure (some joinVerifySec)
+          | .error e =>
+            IO.eprintln s!"  join verify {pairName} FAILED: {e}"
+            joinRejected := true
+            pure none
+        let joinResult : JoinResult := {
+          name := pairName
+          constants := left.constants + right.constants
+          fftCost := joinFftCost
+          executeSec := joinExecuteSec
+          proveSec := joinProveSec
+          peakRss := joinPeak
+          proofSize := joinProofBytes.size
+          verifySec := joinVerifySec?
+          failed := joinVerifySec?.isNone
+        }
+        writeJoinJson joinResult
+        IO.println s!"  {pairName}: join-prove={joinProveSec}s \
+          join-verify={joinVerifySec}s proof={joinProofBytes.size} bytes"
+
   match jsonOut with
-  | some path => IO.println s!"wrote {ordered.size} benchmarks to {path} ({spent}s proving)"
+  | some path =>
+    let rowCount := ordered.size + (if join && !joinRejected then 1 else 0)
+    IO.println s!"wrote {rowCount} benchmarks to {path} ({spent}s proving)"
   | none => IO.println s!"proved {ordered.size} constants ({spent}s); pass --json <path> to emit results"
-  return if ordered.any (·.1.failed) then Ix.Benchmark.Results.exitRejected else 0
+  return if ordered.any (·.1.failed) || joinRejected then
+      Ix.Benchmark.Results.exitRejected
+    else 0
 
 def typecheckCmd : Cli.Cmd := `[Cli|
   typecheck VIA runTypecheckCmd;
@@ -662,12 +940,13 @@ def typecheckCmd : Cli.Cmd := `[Cli|
     "ixe"          : String; "Path to a serialized `Ixon.Env` (e.g. produced by `ix compile`). Required."
     "consts"       : String; "Comma-separated fully-qualified constant names to benchmark (e.g. `Nat.add_comm,String.append`). Same flag/shape as `ix check --consts`, `zisk-host --consts`, and `sp1-host --consts`."
     "consts-file"  : String; "Additionally read constant names from a file (one per line; `#` comments and blank lines ignored). Unions with --consts."
-    "json"      : String; "Write per-constant results JSON to this path. Off by default; normal CLI usage prints only the human-readable summary."
+    "json"      : String; "Write results JSON to this path (per constant, plus one pair row with --join). Off by default; normal CLI usage prints only the human-readable summary."
     "skip-deps";          "Check only each target itself (verify_const, trusting its deps) instead of re-checking its whole transitive closure (verify_claim). Same flag as `zisk-host --skip-deps`."
     "execute-only";       "Execute only (Phase 1: constants / fft-cost / execute-time) and skip proving. The fast per-PR `execute`-mode signal."
     "recursive";          "After each prove, execute and then prove the in-circuit multi-stark verifier over the fresh proof (the fri-verifier-* metrics; see the module docstring). Uses recursion-tuned FRI parameters. Conflicts with --execute-only."
+    "join";               "With --recursive and exactly two resolved constants, prove each as a singleton CheckEnv shard, lift both, then execute/prove/verify one flat aggregate join. Emits a dedicated `left + right` row with join-* metrics. Conflicts with --skip-deps, --execute-only, and --interp."
     "interp";             "Route execution through the generic Aiur bytecode interpreter instead of the codegen'd IxVM kernel - no `lake exe ix codegen` + cargo rebuild needed after `Ix/IxVM/*.lean` edits. Applies to Phase 1, the prove's witness generation, and both --recursive steps. Slower; execute-time rows are not comparable to codegen-mode runs (fft-cost is)."
-    "queries"   : Nat;    "Override the FRI query count of the selected parameter set (default 100, or 50 with --recursive; applies to inner and outer proof alike)."
+    "queries"   : Nat;    "Override the positive FRI query count of the selected parameter set (default 100, or 50 with --recursive; applies to inner and outer proof alike)."
     texray;               "Enable the tracing-texray timeline + RAM breakdown (per-prove spans on stderr). Combined with --json, per-phase span timings are additionally written to `<json>.spans` as JSON Lines for the CI drill-down. Off by default."
 
 ]
diff --git a/Cargo.lock b/Cargo.lock
index db881f753..9f9c6923e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -54,7 +54,7 @@ dependencies = [
  "indexmap",
  "libc",
  "multi-stark",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "tracing",
@@ -190,9 +190,9 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
- "num-bigint",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
@@ -331,6 +331,17 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chacha20"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d524456ba66e72eb8b115ff89e01e497f8e6d11d78b70b1aa13c0fbd97540a81"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
 [[package]]
 name = "chrono"
 version = "0.4.44"
@@ -1735,6 +1746,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -1774,7 +1794,7 @@ dependencies = [
  "ix-common",
  "ix-kernel",
  "ixon",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "sha2 0.10.9",
@@ -1807,7 +1827,7 @@ dependencies = [
  "mimalloc",
  "multi-stark",
  "n0-error",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "serde",
@@ -1839,7 +1859,7 @@ dependencies = [
  "ix-common",
  "ixon",
  "log",
- "num-bigint",
+ "num-bigint 0.4.6",
  "quickcheck",
  "quickcheck_macros",
  "rayon",
@@ -1857,7 +1877,7 @@ dependencies = [
  "ix-common",
  "memmap2",
  "nom",
- "num-bigint",
+ "num-bigint 0.4.6",
  "quickcheck",
  "quickcheck_macros",
  "rayon",
@@ -1875,7 +1895,7 @@ dependencies = [
  "ix-common",
  "ixon",
  "multi-stark",
- "num-bigint",
+ "num-bigint 0.4.6",
  "rayon",
  "rustc-hash",
  "stacker",
@@ -1902,12 +1922,12 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 [[package]]
 name = "lean-ffi"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "bignat",
  "bindgen",
  "cc",
- "num-bigint",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
@@ -2084,10 +2104,11 @@ dependencies = [
 [[package]]
 name = "multi-stark"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=e43201522a95775d1495b4467fbab69fbf7a1ae8#e43201522a95775d1495b4467fbab69fbf7a1ae8"
+source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=2892243e674f9a0b3aca9004a8d00c79a23beec1#2892243e674f9a0b3aca9004a8d00c79a23beec1"
 dependencies = [
  "bincode",
  "itertools 0.14.0",
+ "num-bigint 0.5.1",
  "p3-air",
  "p3-blake3",
  "p3-challenger",
@@ -2096,7 +2117,6 @@ dependencies = [
  "p3-field",
  "p3-fri",
  "p3-goldilocks",
- "p3-interpolation",
  "p3-keccak",
  "p3-matrix",
  "p3-maybe-rayon",
@@ -2371,6 +2391,16 @@ dependencies = [
  "num-traits",
 ]
 
+[[package]]
+name = "num-bigint"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93e7820bc0a80a0238e650327316f929ba18d5be054b647490a3a6a339f3e7c0"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.1"
@@ -2506,18 +2536,19 @@ checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
 
 [[package]]
 name = "p3-air"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-field",
  "p3-matrix",
+ "serde",
  "tracing",
 ]
 
 [[package]]
 name = "p3-blake3"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "blake3",
  "p3-symmetric",
@@ -2526,12 +2557,11 @@ dependencies = [
 
 [[package]]
 name = "p3-challenger"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-field",
  "p3-maybe-rayon",
- "p3-monty-31",
  "p3-symmetric",
  "p3-util",
  "tracing",
@@ -2539,40 +2569,38 @@ dependencies = [
 
 [[package]]
 name = "p3-commit"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
- "p3-challenger",
- "p3-dft",
+ "itertools 0.15.0",
  "p3-field",
- "p3-interpolation",
  "p3-matrix",
+ "p3-multilinear-util",
  "p3-util",
  "serde",
 ]
 
 [[package]]
 name = "p3-dft"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-matrix",
  "p3-maybe-rayon",
  "p3-util",
- "spin 0.10.1",
+ "spin 0.12.3",
  "tracing",
 ]
 
 [[package]]
 name = "p3-field"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
- "num-bigint",
+ "itertools 0.15.0",
+ "num-bigint 0.5.1",
  "p3-maybe-rayon",
  "p3-util",
  "paste",
@@ -2583,32 +2611,31 @@ dependencies = [
 
 [[package]]
 name = "p3-fri"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-challenger",
  "p3-commit",
  "p3-dft",
  "p3-field",
- "p3-interpolation",
  "p3-matrix",
  "p3-maybe-rayon",
+ "p3-security",
  "p3-util",
  "rand 0.10.1",
  "serde",
- "spin 0.10.1",
+ "spin 0.12.3",
  "thiserror",
  "tracing",
 ]
 
 [[package]]
 name = "p3-goldilocks"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "num-bigint",
- "p3-challenger",
+ "num-bigint 0.5.1",
  "p3-dft",
  "p3-field",
  "p3-mds",
@@ -2619,23 +2646,13 @@ dependencies = [
  "paste",
  "rand 0.10.1",
  "serde",
-]
-
-[[package]]
-name = "p3-interpolation"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
-dependencies = [
- "p3-field",
- "p3-matrix",
- "p3-maybe-rayon",
- "p3-util",
+ "spin 0.12.3",
 ]
 
 [[package]]
 name = "p3-keccak"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-symmetric",
  "p3-util",
@@ -2644,10 +2661,10 @@ dependencies = [
 
 [[package]]
 name = "p3-matrix"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-maybe-rayon",
  "p3-util",
@@ -2658,16 +2675,16 @@ dependencies = [
 
 [[package]]
 name = "p3-maybe-rayon"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "rayon",
 ]
 
 [[package]]
 name = "p3-mds"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-dft",
  "p3-field",
@@ -2678,10 +2695,10 @@ dependencies = [
 
 [[package]]
 name = "p3-merkle-tree"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-commit",
  "p3-field",
  "p3-matrix",
@@ -2690,47 +2707,41 @@ dependencies = [
  "p3-util",
  "rand 0.10.1",
  "serde",
+ "spin 0.12.3",
  "thiserror",
  "tracing",
 ]
 
 [[package]]
-name = "p3-monty-31"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+name = "p3-multilinear-util"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
- "num-bigint",
- "p3-dft",
+ "itertools 0.15.0",
  "p3-field",
  "p3-matrix",
  "p3-maybe-rayon",
- "p3-mds",
- "p3-poseidon1",
- "p3-poseidon2",
- "p3-symmetric",
  "p3-util",
- "paste",
  "rand 0.10.1",
  "serde",
- "spin 0.10.1",
  "tracing",
 ]
 
 [[package]]
 name = "p3-poseidon1"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-field",
+ "p3-mds",
  "p3-symmetric",
  "rand 0.10.1",
 ]
 
 [[package]]
 name = "p3-poseidon2"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
  "p3-field",
  "p3-mds",
@@ -2739,12 +2750,24 @@ dependencies = [
  "rand 0.10.1",
 ]
 
+[[package]]
+name = "p3-security"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
+dependencies = [
+ "libm",
+ "p3-air",
+ "p3-field",
+ "p3-util",
+ "serde",
+]
+
 [[package]]
 name = "p3-symmetric"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
- "itertools 0.14.0",
+ "itertools 0.15.0",
  "p3-field",
  "p3-util",
  "serde",
@@ -2752,11 +2775,11 @@ dependencies = [
 
 [[package]]
 name = "p3-util"
-version = "0.5.1"
-source = "git+https://github.com/Plonky3/Plonky3?rev=e9d75614dd6816f9b5dbb4413c69be63536efd64#e9d75614dd6816f9b5dbb4413c69be63536efd64"
+version = "0.6.0"
+source = "git+https://github.com/Plonky3/Plonky3?rev=3c84c158c0939345a3becba60a387643935593d2#3c84c158c0939345a3becba60a387643935593d2"
 dependencies = [
+ "p3-maybe-rayon",
  "serde",
- "transpose",
 ]
 
 [[package]]
@@ -3158,6 +3181,7 @@ version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
 dependencies = [
+ "chacha20",
  "getrandom 0.4.2",
  "rand_core 0.10.1",
 ]
@@ -3614,6 +3638,12 @@ name = "spin"
 version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3"
+
+[[package]]
+name = "spin"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0134f9043ed38b087ac4f7d4af44c79e2c9e5094421fe3164f435ce585953b10"
 dependencies = [
  "lock_api",
 ]
@@ -3647,12 +3677,6 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
-[[package]]
-name = "strength_reduce"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
-
 [[package]]
 name = "strsim"
 version = "0.11.1"
@@ -4064,16 +4088,6 @@ dependencies = [
  "tracing-subscriber",
 ]
 
-[[package]]
-name = "transpose"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
-dependencies = [
- "num-integer",
- "strength_reduce",
-]
-
 [[package]]
 name = "try-lock"
 version = "0.2.5"
diff --git a/Cargo.toml b/Cargo.toml
index 1791ae265..0b1ab7f29 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,8 +42,8 @@ ixon = { path = "crates/ixon" }
 ix-kernel = { path = "crates/kernel" }
 
 # lean-ffi tree (lean-ffi crate + factored-out bignat sub-crate)
-bignat = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" }
-lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "2a9c91eba44ea791978a086a6a19b3a922edfee5" }
+bignat = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "93c7e52952ae94546be08313f4ff3922984c84d5" }
+lean-ffi = { git = "https://github.com/argumentcomputer/lean-ffi.git", rev = "93c7e52952ae94546be08313f4ff3922984c84d5" }
 
 # External shared deps
 anyhow = "1"
@@ -56,7 +56,7 @@ libc = "0.2"
 log = "0.4"
 memmap2 = "0.9"
 mimalloc = { version = "0.1", default-features = false }
-multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "e43201522a95775d1495b4467fbab69fbf7a1ae8" }
+multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "2892243e674f9a0b3aca9004a8d00c79a23beec1" }
 nom = "7.1.3"
 num-bigint = "0.4.6"
 quickcheck = "1.0.3"
@@ -98,7 +98,6 @@ filter_map_next = "warn"
 flat_map_option = "warn"
 fn_to_numeric_cast = "warn"
 fn_to_numeric_cast_with_truncation = "warn"
-from_iter_instead_of_collect = "warn"
 implicit_clone = "warn"
 inefficient_to_string = "warn"
 invalid_upcast_comparisons = "warn"
diff --git a/Ix/Aggr.lean b/Ix/Aggr.lean
new file mode 100644
index 000000000..e7861ce4a
--- /dev/null
+++ b/Ix/Aggr.lean
@@ -0,0 +1,215 @@
+module
+public import Blake3.Rust
+public import Ix.Aggr.Circuit
+public import Ix.Aggr.Host
+public import Ix.AssumptionTree
+public import Ix.MultiStark
+
+/-!
+# The `ixAggr` toplevel
+
+`ixAggr` is the recursive aggregation system for IxVM proofs. It reuses the
+Ix-agnostic Multi-STARK verifier modules (`Ix/MultiStark/…`, unmodified) and
+adds the heterogeneous `ix_aggr` entrypoint from `Ix/Aggr/Circuit.lean` — one
+circuit that wraps or joins any mix of IxVM and `ix_aggr` child proofs, with
+the shape chosen by advice. There is no separate lift stage: an IxVM proof
+enters the recursion system through a wrap or directly as a join child.
+
+This module is also the single home of the host half of the wire contracts:
+the allowed blob, the public input packing, and the shape codes. Callers must
+reproduce these byte-for-byte — the blob and the output claim are Blake3
+digest-bound in-circuit.
+-/
+
+public section
+
+namespace Aggr
+
+/-- The full aggregation toplevel: every Multi-STARK verifier module (via
+`MultiStark.multiStarkFull`, unmodified) plus the `ix_aggr` circuit —
+unpruned. Only tests should build on this; production uses `ixAggr`. -/
+def ixAggrFull : Except Aiur.Global Aiur.Source.Toplevel := do
+  let t ← MultiStark.multiStarkFull
+  t.merge circuit
+
+/-- The production aggregation toplevel: `ixAggrFull` pruned to `ix_aggr`'s
+call closure. Every compiled function is a committed circuit whose openings
+pad every proof of the system's execution, so functions only reachable from
+unrelated entries (`verify_multi_stark_proof`, kernel-oriented helpers of the
+shared modules, test/bench entries) cost real proof bytes if kept. -/
+def ixAggr : Except Aiur.Global Aiur.Source.Toplevel := do
+  let t ← ixAggrFull
+  pure (t.prune [`ix_aggr])
+
+/-! ## Identity and public input -/
+
+/-- Pack a Blake3 digest four bytes per Goldilocks element, little-endian —
+the layout `b3_pack` produces in-circuit. -/
+def digestGs (bytes : ByteArray) : Array Aiur.G :=
+  let h := (Blake3.Rust.hash bytes).val.data
+  (Array.range 8).map fun i =>
+    .ofNat (h[4*i]!.toNat + 256 * h[4*i+1]!.toNat
+      + 65536 * h[4*i+2]!.toNat + 16777216 * h[4*i+3]!.toNat)
+
+/-- The digest-bound 80-byte identity blob:
+
+`blake3(ixvm vk) ‖ verify_claim index as u64-LE ‖ blake3(self vk) ‖
+ix_aggr index as u64-LE`.
+
+The verifying keys stay outside the public input. Their digests and both
+entrypoint indices form the stable identity that every node of an aggregation
+tree pins transitively — the blob is identical at every node regardless of
+shape. The indices must be explicit because the Source DSL cannot materialize
+its compiler-assigned function index inside a circuit. -/
+def allowedBlob (ixvmVkBytes : ByteArray) (verifyClaimIdx : Nat)
+    (selfVkBytes : ByteArray) (aggrIdx : Nat) : ByteArray :=
+  let ixvmDigest := (Blake3.Rust.hash ixvmVkBytes).val.data
+  let selfDigest := (Blake3.Rust.hash selfVkBytes).val.data
+  ⟨ixvmDigest ++ MultiStark.u64le verifyClaimIdx ++
+    selfDigest ++ MultiStark.u64le aggrIdx⟩
+
+/-- Public input of `ix_aggr`: the packed Blake3 digest of the identity blob
+followed by the packed digest of the output `CheckEnv` claim bytes. -/
+def pubInput (allowed outClaimBytes : ByteArray) : Array Aiur.G :=
+  digestGs allowed ++ digestGs outClaimBytes
+
+/-! ## Shapes -/
+
+/-- Which system a child proof verifies against. -/
+inductive ChildKind where
+  | ixvm
+  | aggr
+  deriving BEq, Repr
+
+def ChildKind.code : ChildKind → Nat
+  | .ixvm => 0
+  | .aggr => 1
+
+/-- The advice byte selecting a wrap or flat pair: `0`/`1` wrap one IxVM /
+`ix_aggr` child; `2`–`5` fold a flat pair, `2 + 2·left + right` with IxVM = 0
+and `ix_aggr` = 1. -/
+def shapeCode : (children : ChildKind × Option ChildKind) → Nat
+  | (kind, none) => kind.code
+  | (left, some right) => 2 + 2 * left.code + right.code
+
+/-- Structural pair shapes `6`–`9`: `6 + 2·left + right`. Wraps have no
+structural form. -/
+def structuralShapeCode (left right : ChildKind) : Nat :=
+  6 + 2 * left.code + right.code
+
+/-! ## Native-FFI advice framing
+
+`executeIxAggr` / `proveIxAggr` take the digest-addressed advice as compact
+byte blobs and expand them into IO channels natively. The circuit still
+re-hashes/re-roots every payload; these host-side keys only make the advice
+addressable — they are not trusted bindings. -/
+
+/-- Four little-endian bytes of `n`, used only by the compact native-FFI
+framing below. Advice blobs are bounded by the `ByteArray`/Rust address
+space in practice and therefore never approach the `u32` limit. -/
+private def u32le (n : Nat) : Array UInt8 :=
+  (Array.range 4).map (fun i => UInt8.ofNat ((n >>> (8 * i)) % 256))
+
+/-- Encode content-addressed byte blobs for the native FFI as
+
+`count:u32-LE ‖ (key:32 ‖ length:u32-LE ‖ payload)*`. -/
+private def keyedBlobs
+    (entries : Array (ByteArray × ByteArray)) : ByteArray := Id.run do
+  assert! entries.size < 4294967296
+  let mut out := u32le entries.size
+  for (key, payload) in entries do
+    assert! key.size == 32
+    assert! payload.size < 4294967296
+    out := out ++ key.data ++ u32le payload.size ++ payload.data
+  return ⟨out⟩
+
+/-- Pack `CheckEnv` claim preimages for the native FFI. Each key is computed
+as Blake3(payload), matching IO channel 4's packed-digest lookup. -/
+def preimagesBlob (preimages : Array ByteArray) : ByteArray :=
+  keyedBlobs <| preimages.map fun bytes =>
+    ((Blake3.Rust.hash bytes).val, bytes)
+
+/-- Pack serialized canonical trees for the native FFI. Channel 5 keys use
+the raw 32-byte tree root. The in-circuit loader independently checks strict
+leaf order and recomputes the canonical root. -/
+def treesBlob (trees : Array Ix.AssumptionTree) : ByteArray :=
+  keyedBlobs <| trees.map fun tree =>
+    (tree.root.hash, Ix.AssumptionTree.ser tree)
+
+/-- Encode one structural-discharge choice. A missing path means "carry" and
+encodes as `0`; a present path encodes as
+`1 ‖ count:u8 ‖ (side:u8 ‖ sibling:32)*`. The side byte is zero when the
+sibling is on the left and one when it is on the right. -/
+def pathPayload (path? : Option Ix.Merkle.MerklePath) : ByteArray := Id.run do
+  match path? with
+  | none => return ⟨#[0]⟩
+  | some path =>
+    assert! path.size ≤ 64
+    let mut out : Array UInt8 := #[1, UInt8.ofNat path.size]
+    for (sibling, isLeft) in path do
+      out := out.push (if isLeft then 0 else 1)
+      out := out ++ sibling.hash.data
+    return ⟨out⟩
+
+/-- Pack one structural-discharge choice per unique input-assumption candidate
+for IO channel 6. -/
+def pathsBlob
+    (paths : Array (Address × Option Ix.Merkle.MerklePath)) : ByteArray :=
+  keyedBlobs <| paths.map fun (candidate, path?) =>
+    (candidate.hash, pathPayload path?)
+
+/-! ## Interpreter-side advice assembly
+
+These helpers place advice on the IO channels exactly as the circuit reads
+them, for the pure-Lean `Bytecode.Toplevel.execute` path. The native
+execute/prove FFI will consume byte blobs with the same channel layout. -/
+
+/-- One byte per Goldilocks element, the layout `#read_byte_stream` expects. -/
+def byteGs (bytes : ByteArray) : Array Aiur.G :=
+  bytes.data.map .ofUInt8
+
+/-- Channel 4: a `CheckEnv` claim preimage, keyed by its packed digest. The
+circuit re-hashes the payload against the key, so host keys are addressing,
+not trusted bindings. -/
+def extendPreimage (io : Aiur.IOBuffer) (bytes : ByteArray) : Aiur.IOBuffer :=
+  io.extend 4 (digestGs bytes) (byteGs bytes)
+
+/-- Channel 5: one serialized canonical tree, keyed by its raw 32-byte root.
+The circuit independently checks strict leaf order and recomputes the
+canonical root. -/
+def extendTree (io : Aiur.IOBuffer) (tree : Ix.AssumptionTree) : Aiur.IOBuffer :=
+  io.extend 5 (byteGs tree.root.hash) (byteGs (Ix.AssumptionTree.ser tree))
+
+/-- Channel 6: one structural carried/discharged choice keyed by the raw
+candidate address. The 32-element address key cannot collide with the shape's
+one-element `[0]` key. -/
+def extendPath (io : Aiur.IOBuffer) (candidate : Address)
+    (path? : Option Ix.Merkle.MerklePath) : Aiur.IOBuffer :=
+  io.extend 6 (byteGs candidate.hash) (byteGs (pathPayload path?))
+
+/-- Channels 0/2 for one child slot: expanded proof advice and serialized
+claims. Compact proof wire bytes are not an in-circuit input. -/
+def extendChild (io : Aiur.IOBuffer) (key : Nat)
+    (proofAdviceBytes claimsBytes : ByteArray) : Aiur.IOBuffer :=
+  let io := io.extend 0 #[.ofNat key] (byteGs proofAdviceBytes)
+  io.extend 2 #[.ofNat key] (byteGs claimsBytes)
+
+/-- Channels 3 and 6: the identity blob and the shape byte. -/
+def extendIdentity (io : Aiur.IOBuffer) (allowed : ByteArray)
+    (shape : Nat) : Aiur.IOBuffer :=
+  let io := io.extend 3 #[.ofNat 0] (byteGs allowed)
+  io.extend 6 #[.ofNat 0] #[.ofNat shape]
+
+/-- Channel 1: vk bytes for one child kind (key 0 = IxVM, key 1 = self). -/
+def extendVk (io : Aiur.IOBuffer) (kind : ChildKind)
+    (vkBytes : ByteArray) : Aiur.IOBuffer :=
+  io.extend 1 #[.ofNat kind.code] (byteGs vkBytes)
+
+/-- Channel 2 key 2: the output claim bytes of a pair fold. Wrap shapes bind
+the output digest against the child claim directly and read no output bytes. -/
+def extendOutputClaim (io : Aiur.IOBuffer) (bytes : ByteArray) : Aiur.IOBuffer :=
+  io.extend 2 #[.ofNat 2] (byteGs bytes)
+
+end Aggr
+
+end
diff --git a/Ix/Aggr/Circuit.lean b/Ix/Aggr/Circuit.lean
new file mode 100644
index 000000000..b351c22fc
--- /dev/null
+++ b/Ix/Aggr/Circuit.lean
@@ -0,0 +1,802 @@
+module
+public import Ix.Aiur.Meta
+public import Ix.IxVM.Blake3
+public import Ix.MultiStark.Verifier
+
+/-!
+# Heterogeneous recursive aggregation circuit
+
+One entrypoint, `ix_aggr`, subsumes wrapping and joining. A non-deterministic
+shape hint (IO channel 6) selects one of ten verified forms:
+
+| shape | children                  | statement fold                          |
+|-------|---------------------------|-----------------------------------------|
+| 0     | one IxVM proof            | pass-through (wrap)                     |
+| 1     | one `ix_aggr` proof       | pass-through (wrap)                     |
+| 2     | IxVM, IxVM                | union / difference                      |
+| 3     | IxVM, `ix_aggr`           | union / difference                      |
+| 4     | `ix_aggr`, IxVM           | union / difference                      |
+| 5     | `ix_aggr`, `ix_aggr`      | union / difference                      |
+| 6     | IxVM, IxVM                | structural root / path discharge        |
+| 7     | IxVM, `ix_aggr`           | structural root / path discharge        |
+| 8     | `ix_aggr`, IxVM           | structural root / path discharge        |
+| 9     | `ix_aggr`, `ix_aggr`      | structural root / path discharge        |
+
+The hint is advice, not trust: every shape verifies its children against the
+verifying key demanded by that shape (digest-bound to the allowed blob) and
+then demands that shape's exact claim layout, so a wrong hint fails either the
+proof verification or a digest/shape assertion.
+
+The public statement is uniform across all shapes:
+
+`blake3(allowed_blob) ‖ blake3(output CheckEnv claim bytes)`,
+
+packed four bytes per Goldilocks element. The 80-byte allowed blob is
+
+`blake3(ixvm vk) ‖ verify_claim idx (u64 LE) ‖ blake3(self vk) ‖ ix_aggr idx
+(u64 LE)`
+
+and is carried unchanged by every node of an aggregation tree: a parent
+asserts its `ix_aggr` children bind the *same* allowed digest, which pins both
+verifying keys and both entrypoint indices transitively. The indices must be
+explicit because the Source DSL cannot materialize its compiler-assigned
+function index inside a circuit.
+
+Child claims normalize to one `CheckEnv` statement each:
+
+* IxVM child — 10-word `verify_claim` claim `[0, verify_idx, digest(8)]`,
+  where the digest packs `blake3` of the serialized `CheckEnv` claim.
+* `ix_aggr` child — 18-word claim `[0, aggr_idx, allowed(8), digest(8)]`.
+
+Wrap shapes bind the output digest to the child's `CheckEnv` digest directly
+and open nothing. Flat pair shapes open both `CheckEnv` preimages (channel 4),
+re-root the canonical subject/assumption trees (channel 5), and prove
+
+`subjects = subjects_L ∪ subjects_R`
+
+`assumptions = (assumptions_L ∪ assumptions_R) ∖ subjects`.
+
+Structural pair shapes instead bind
+`subjects = nodeHash(subjects_L.root, subjects_R.root)` and account for every
+input assumption by either carrying it into the canonical output assumptions
+or discharging it with a strict Merkle inclusion path on channel 6.
+
+All address-list operations use bytewise address comparison. Pointer identity
+is never used as set equality: Aiur memory constrains pointers to be unique,
+not stored values to be globally deduplicated.
+
+## IO channels
+
+| channel | key                  | payload                                  |
+|---------|----------------------|------------------------------------------|
+| 0       | `[0]` / `[1]`        | child proof bytes                        |
+| 1       | `[kind]`             | vk bytes (0 = IxVM, 1 = self)            |
+| 2       | `[0]` / `[1]`, `[2]` | child claims; output claim bytes         |
+| 3       | `[0]`                | 80-byte allowed blob                     |
+| 4       | packed digest        | `CheckEnv` claim preimages               |
+| 5       | raw 32-byte root     | serialized canonical `AssumptionTree`s   |
+| 6       | `[0]` / address      | shape byte (0–9) / structural path choice |
+-/
+
+public section
+
+namespace Aggr
+
+def circuit := ⟦
+  enum AggrNextAssumption {
+    Done,
+    More(Addr, List‹Addr›, List‹Addr›)
+  }
+
+  /- ## Small strict byte readers
+
+  The aggregator only decodes fixed-width digests, u64 function indices, and
+  single-byte tags.  Keeping these readers local avoids pulling the full IxVM
+  Ixon decoder (and all of its kernel-only types) into the recursion system.
+  -/
+
+  fn aggr_read_byte(stream: ByteStream) -> (U8, ByteStream) {
+    let ListNode.Cons(byte, rest) = load(stream);
+    (byte, rest)
+  }
+
+  fn aggr_read_address(stream: ByteStream) -> (Addr, ByteStream) {
+    let ListNode.Cons(b0, s) = load(stream);
+    let ListNode.Cons(b1, s) = load(s);
+    let ListNode.Cons(b2, s) = load(s);
+    let ListNode.Cons(b3, s) = load(s);
+    let ListNode.Cons(b4, s) = load(s);
+    let ListNode.Cons(b5, s) = load(s);
+    let ListNode.Cons(b6, s) = load(s);
+    let ListNode.Cons(b7, s) = load(s);
+    let ListNode.Cons(b8, s) = load(s);
+    let ListNode.Cons(b9, s) = load(s);
+    let ListNode.Cons(b10, s) = load(s);
+    let ListNode.Cons(b11, s) = load(s);
+    let ListNode.Cons(b12, s) = load(s);
+    let ListNode.Cons(b13, s) = load(s);
+    let ListNode.Cons(b14, s) = load(s);
+    let ListNode.Cons(b15, s) = load(s);
+    let ListNode.Cons(b16, s) = load(s);
+    let ListNode.Cons(b17, s) = load(s);
+    let ListNode.Cons(b18, s) = load(s);
+    let ListNode.Cons(b19, s) = load(s);
+    let ListNode.Cons(b20, s) = load(s);
+    let ListNode.Cons(b21, s) = load(s);
+    let ListNode.Cons(b22, s) = load(s);
+    let ListNode.Cons(b23, s) = load(s);
+    let ListNode.Cons(b24, s) = load(s);
+    let ListNode.Cons(b25, s) = load(s);
+    let ListNode.Cons(b26, s) = load(s);
+    let ListNode.Cons(b27, s) = load(s);
+    let ListNode.Cons(b28, s) = load(s);
+    let ListNode.Cons(b29, s) = load(s);
+    let ListNode.Cons(b30, s) = load(s);
+    let ListNode.Cons(b31, s) = load(s);
+    (store([b0, b1, b2, b3, b4, b5, b6, b7,
+            b8, b9, b10, b11, b12, b13, b14, b15,
+            b16, b17, b18, b19, b20, b21, b22, b23,
+            b24, b25, b26, b27, b28, b29, b30, b31]), s)
+  }
+
+  fn aggr_put_address(addr: Addr, rest: ByteStream) -> ByteStream {
+    let a = load(addr);
+    let s31 = store(ListNode.Cons(a[31], rest));
+    let s30 = store(ListNode.Cons(a[30], s31));
+    let s29 = store(ListNode.Cons(a[29], s30));
+    let s28 = store(ListNode.Cons(a[28], s29));
+    let s27 = store(ListNode.Cons(a[27], s28));
+    let s26 = store(ListNode.Cons(a[26], s27));
+    let s25 = store(ListNode.Cons(a[25], s26));
+    let s24 = store(ListNode.Cons(a[24], s25));
+    let s23 = store(ListNode.Cons(a[23], s24));
+    let s22 = store(ListNode.Cons(a[22], s23));
+    let s21 = store(ListNode.Cons(a[21], s22));
+    let s20 = store(ListNode.Cons(a[20], s21));
+    let s19 = store(ListNode.Cons(a[19], s20));
+    let s18 = store(ListNode.Cons(a[18], s19));
+    let s17 = store(ListNode.Cons(a[17], s18));
+    let s16 = store(ListNode.Cons(a[16], s17));
+    let s15 = store(ListNode.Cons(a[15], s16));
+    let s14 = store(ListNode.Cons(a[14], s15));
+    let s13 = store(ListNode.Cons(a[13], s14));
+    let s12 = store(ListNode.Cons(a[12], s13));
+    let s11 = store(ListNode.Cons(a[11], s12));
+    let s10 = store(ListNode.Cons(a[10], s11));
+    let s9 = store(ListNode.Cons(a[9], s10));
+    let s8 = store(ListNode.Cons(a[8], s9));
+    let s7 = store(ListNode.Cons(a[7], s8));
+    let s6 = store(ListNode.Cons(a[6], s7));
+    let s5 = store(ListNode.Cons(a[5], s6));
+    let s4 = store(ListNode.Cons(a[4], s5));
+    let s3 = store(ListNode.Cons(a[3], s4));
+    let s2 = store(ListNode.Cons(a[2], s3));
+    let s1 = store(ListNode.Cons(a[1], s2));
+    store(ListNode.Cons(a[0], s1))
+  }
+
+  fn aggr_pack_address(addr: Addr) -> [G; 8] {
+    let a = load(addr);
+    [@b3_pack_w([a[0], a[1], a[2], a[3]]),
+     @b3_pack_w([a[4], a[5], a[6], a[7]]),
+     @b3_pack_w([a[8], a[9], a[10], a[11]]),
+     @b3_pack_w([a[12], a[13], a[14], a[15]]),
+     @b3_pack_w([a[16], a[17], a[18], a[19]]),
+     @b3_pack_w([a[20], a[21], a[22], a[23]]),
+     @b3_pack_w([a[24], a[25], a[26], a[27]]),
+     @b3_pack_w([a[28], a[29], a[30], a[31]])]
+  }
+
+  -- `Ix.Merkle.nodeHash`: Blake3 of `0x01 ‖ left ‖ right`.
+  fn aggr_node_hash(left: Addr, right: Addr) -> Addr {
+    let tail = aggr_put_address(left,
+      aggr_put_address(right, store(ListNode.Nil)));
+    bytes_to_addr(store(ListNode.Cons(1u8, tail)))
+  }
+
+  -- `Ix.Merkle.leafHash`: Blake3 of `0x00 ‖ address`.
+  fn aggr_leaf_hash(addr: Addr) -> Addr {
+    let tail = aggr_put_address(addr, store(ListNode.Nil));
+    bytes_to_addr(store(ListNode.Cons(0u8, tail)))
+  }
+
+  fn aggr_pack_be4(a: U8, b: U8, c: U8, d: U8) -> G {
+    ((to_field(a) * 256 + to_field(b)) * 256 + to_field(c)) * 256
+      + to_field(d)
+  }
+
+  -- Byte-lexicographic address order: 0 = less, 1 = equal, 2 = greater.
+  -- Four-byte big-endian words stay below 2^32, so native field equality and
+  -- `u32_less_than` are exact.
+  fn aggr_address_order(a: Addr, b: Addr) -> G {
+    let av = load(a);
+    let bv = load(b);
+    let aw0 = @aggr_pack_be4(av[0], av[1], av[2], av[3]);
+    let bw0 = @aggr_pack_be4(bv[0], bv[1], bv[2], bv[3]);
+    match aw0 - bw0 {
+      0 =>
+        let aw1 = @aggr_pack_be4(av[4], av[5], av[6], av[7]);
+        let bw1 = @aggr_pack_be4(bv[4], bv[5], bv[6], bv[7]);
+        match aw1 - bw1 {
+          0 =>
+            let aw2 = @aggr_pack_be4(av[8], av[9], av[10], av[11]);
+            let bw2 = @aggr_pack_be4(bv[8], bv[9], bv[10], bv[11]);
+            match aw2 - bw2 {
+              0 =>
+                let aw3 = @aggr_pack_be4(av[12], av[13], av[14], av[15]);
+                let bw3 = @aggr_pack_be4(bv[12], bv[13], bv[14], bv[15]);
+                match aw3 - bw3 {
+                  0 =>
+                    let aw4 = @aggr_pack_be4(av[16], av[17], av[18], av[19]);
+                    let bw4 = @aggr_pack_be4(bv[16], bv[17], bv[18], bv[19]);
+                    match aw4 - bw4 {
+                      0 =>
+                        let aw5 = @aggr_pack_be4(av[20], av[21], av[22], av[23]);
+                        let bw5 = @aggr_pack_be4(bv[20], bv[21], bv[22], bv[23]);
+                        match aw5 - bw5 {
+                          0 =>
+                            let aw6 = @aggr_pack_be4(av[24], av[25], av[26], av[27]);
+                            let bw6 = @aggr_pack_be4(bv[24], bv[25], bv[26], bv[27]);
+                            match aw6 - bw6 {
+                              0 =>
+                                let aw7 = @aggr_pack_be4(av[28], av[29], av[30], av[31]);
+                                let bw7 = @aggr_pack_be4(bv[28], bv[29], bv[30], bv[31]);
+                                match aw7 - bw7 {
+                                  0 => 1,
+                                  _ => match u32_less_than(aw7, bw7) { 1 => 0, _ => 2, },
+                                },
+                              _ => match u32_less_than(aw6, bw6) { 1 => 0, _ => 2, },
+                            },
+                          _ => match u32_less_than(aw5, bw5) { 1 => 0, _ => 2, },
+                        },
+                      _ => match u32_less_than(aw4, bw4) { 1 => 0, _ => 2, },
+                    },
+                  _ => match u32_less_than(aw3, bw3) { 1 => 0, _ => 2, },
+                },
+              _ => match u32_less_than(aw2, bw2) { 1 => 0, _ => 2, },
+            },
+          _ => match u32_less_than(aw1, bw1) { 1 => 0, _ => 2, },
+        },
+      _ => match u32_less_than(aw0, bw0) { 1 => 0, _ => 2, },
+    }
+  }
+
+  fn aggr_assert_strict_sorted(leaves: List‹Addr›) {
+    match load(leaves) {
+      ListNode.Nil => (),
+      ListNode.Cons(a, rest) =>
+        match load(rest) {
+          ListNode.Nil => (),
+          ListNode.Cons(b, _) =>
+            assert_eq!(aggr_address_order(a, b), 0,
+              "aggr: tree leaves are not strictly sorted");
+            aggr_assert_strict_sorted(rest),
+        },
+    }
+  }
+
+  -- Parse an `AssumptionTree` body into its in-order real leaves. Padding is
+  -- omitted. The serialized shape is advice; canonical-root recomputation
+  -- below binds the resulting sorted leaf set to the requested root.
+  fn aggr_parse_tree_body(stream: ByteStream) -> (List‹Addr›, ByteStream) {
+    let (tag, rest) = aggr_read_byte(stream);
+    match tag {
+      0 =>
+        let (addr, stop) = aggr_read_address(rest);
+        (store(ListNode.Cons(addr, store(ListNode.Nil))), stop),
+      1 => (store(ListNode.Nil), rest),
+      2 =>
+        let (left, s2) = aggr_parse_tree_body(rest);
+        let (right, stop) = aggr_parse_tree_body(s2);
+        (list_concat(left, right), stop),
+    }
+  }
+
+  fn aggr_leaf_hashes(leaves: List‹Addr›) -> List‹Addr› {
+    match load(leaves) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(addr, rest) =>
+        store(ListNode.Cons(aggr_leaf_hash(addr), aggr_leaf_hashes(rest))),
+    }
+  }
+
+  -- One canonical Merkle reduction level. An odd last node is paired with
+  -- the zero-address padding sentinel.
+  fn aggr_pair_hashes(nodes: List‹Addr›) -> List‹Addr› {
+    match load(nodes) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(left, rest) =>
+        match load(rest) {
+          ListNode.Nil =>
+            let zero = store([0u8; 32]);
+            store(ListNode.Cons(aggr_node_hash(left, zero), store(ListNode.Nil))),
+          ListNode.Cons(right, tail) =>
+            store(ListNode.Cons(aggr_node_hash(left, right), aggr_pair_hashes(tail))),
+        },
+    }
+  }
+
+  fn aggr_reduce_hashes(nodes: List‹Addr›) -> Addr {
+    let ListNode.Cons(root, rest) = load(nodes);
+    match load(rest) {
+      ListNode.Nil => root,
+      _ => aggr_reduce_hashes(aggr_pair_hashes(nodes)),
+    }
+  }
+
+  fn aggr_canonical_root(leaves: List‹Addr›) -> Addr {
+    aggr_reduce_hashes(aggr_leaf_hashes(leaves))
+  }
+
+  fn aggr_load_canonical_tree(root: Addr) -> List‹Addr› {
+    let raw = load(root);
+    let (idx, len) = io_get_info(5, raw);
+    let bytes = #read_byte_stream(5, idx, len);
+    let (tag, body) = aggr_read_byte(bytes);
+    assert_eq!(tag, 0xE2u8, "aggr: tree has the wrong Ixon tag");
+    let (leaves, stop) = aggr_parse_tree_body(body);
+    assert_eq!(load(stop), ListNode.Nil,
+      "aggr: trailing bytes after AssumptionTree");
+    assert_eq!(list_is_empty(leaves), 0,
+      "aggr: a present tree must contain at least one leaf");
+    aggr_assert_strict_sorted(leaves);
+    let expected = aggr_canonical_root(leaves);
+    assert_eq!(address_eq(expected, root), 1,
+      "aggr: tree leaves do not reproduce the canonical root");
+    leaves
+  }
+
+  fn aggr_load_optional_tree(root: Option‹Addr›) -> List‹Addr› {
+    match root {
+      Option.None => store(ListNode.Nil),
+      Option.Some(addr) => aggr_load_canonical_tree(addr),
+    }
+  }
+
+  fn aggr_assert_same_list(left: List‹Addr›, right: List‹Addr›) {
+    match (load(left), load(right)) {
+      (ListNode.Nil, ListNode.Nil) => (),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        assert_eq!(address_eq(a, b), 1, "aggr: set element mismatch");
+        aggr_assert_same_list(ar, br),
+    }
+  }
+
+  -- Assert `output` is the sorted, deduplicated union of two sorted unique
+  -- inputs. The merge is linear in the number of leaves.
+  fn aggr_assert_union(left: List‹Addr›, right: List‹Addr›,
+      output: List‹Addr›) {
+    match (load(left), load(right)) {
+      (ListNode.Nil, _) => aggr_assert_same_list(right, output),
+      (_, ListNode.Nil) => aggr_assert_same_list(left, output),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        let ListNode.Cons(o, or) = load(output);
+        match aggr_address_order(a, b) {
+          0 =>
+            assert_eq!(address_eq(a, o), 1, "aggr: subject union mismatch");
+            aggr_assert_union(ar, right, or),
+          1 =>
+            assert_eq!(address_eq(a, o), 1, "aggr: subject union mismatch");
+            aggr_assert_union(ar, br, or),
+          _ =>
+            assert_eq!(address_eq(b, o), 1, "aggr: subject union mismatch");
+            aggr_assert_union(left, br, or),
+        },
+    }
+  }
+
+  -- Select the next unique value from the union of two sorted assumption
+  -- lists, returning the unconsumed tails.
+  fn aggr_next_assumption(left: List‹Addr›, right: List‹Addr›)
+      -> AggrNextAssumption {
+    match (load(left), load(right)) {
+      (ListNode.Nil, ListNode.Nil) => AggrNextAssumption.Done,
+      (ListNode.Cons(a, ar), ListNode.Nil) =>
+        AggrNextAssumption.More(a, ar, right),
+      (ListNode.Nil, ListNode.Cons(b, br)) =>
+        AggrNextAssumption.More(b, left, br),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        match aggr_address_order(a, b) {
+          0 => AggrNextAssumption.More(a, ar, right),
+          1 => AggrNextAssumption.More(a, ar, br),
+          _ => AggrNextAssumption.More(b, left, br),
+        },
+    }
+  }
+
+  -- Find `target` in a sorted subject list, discarding subject values below it
+  -- and returning the suffix useful for the next (strictly larger) target.
+  fn aggr_seek_subject(target: Addr, subjects: List‹Addr›)
+      -> (G, List‹Addr›) {
+    match load(subjects) {
+      ListNode.Nil => (0, subjects),
+      ListNode.Cons(subject, rest) =>
+        match aggr_address_order(subject, target) {
+          0 => aggr_seek_subject(target, rest),
+          1 => (1, rest),
+          _ => (0, subjects),
+        },
+    }
+  }
+
+  -- Assert `output = (left ∪ right) ∖ subjects`, all lists sorted and
+  -- duplicate-free. Subject scan state is threaded so the check is linear.
+  fn aggr_assert_difference(left: List‹Addr›, right: List‹Addr›,
+      subjects: List‹Addr›, output: List‹Addr›) {
+    match aggr_next_assumption(left, right) {
+      AggrNextAssumption.Done =>
+        assert_eq!(load(output), ListNode.Nil,
+          "aggr: output has an extra assumption");
+        (),
+      AggrNextAssumption.More(candidate, left_rest, right_rest) =>
+        let (discharged, subject_rest) = aggr_seek_subject(candidate, subjects);
+        match discharged {
+          1 => aggr_assert_difference(left_rest, right_rest, subject_rest, output),
+          _ =>
+            let ListNode.Cons(actual, output_rest) = load(output);
+            assert_eq!(address_eq(candidate, actual), 1,
+              "aggr: outstanding assumption mismatch");
+            aggr_assert_difference(left_rest, right_rest, subject_rest, output_rest),
+        },
+    }
+  }
+
+  /- ## Structural assumption discharge
+
+  Structural pairs do not open their subject trees. Channel 6 carries one
+  choice for every unique input-assumption candidate, keyed by the raw
+  candidate address. A carried candidate must occur next in the canonical
+  output-assumption list; a discharged candidate must supply a valid Merkle
+  path into the one-hash structural output root.
+  -/
+
+  fn aggr_fold_path(hash: Addr, remaining: G, stream: ByteStream)
+      -> (Addr, ByteStream) {
+    match remaining {
+      0 => (hash, stream),
+      _ =>
+        let (side, s1) = aggr_read_byte(stream);
+        assert_eq!(u8_less_than(side, 2u8), 1,
+          "aggr structural: path side must be 0 or 1");
+        let (sibling, s2) = aggr_read_address(s1);
+        let parent = match side {
+          0 => aggr_node_hash(sibling, hash),
+          _ => aggr_node_hash(hash, sibling),
+        };
+        aggr_fold_path(parent, remaining - 1, s2),
+    }
+  }
+
+  -- Return 1 when `candidate` is discharged by a path into `root`, or 0
+  -- when it is explicitly carried. The payload is strict:
+  --   carried:     0
+  --   discharged: 1 || count:u8 || (side:u8 || sibling:32)*
+  fn aggr_discharge_choice(candidate: Addr, root: Addr) -> G {
+    let (idx, len) = io_get_info(6, load(candidate));
+    let bytes = #read_byte_stream(6, idx, len);
+    let (choice, rest) = aggr_read_byte(bytes);
+    assert_eq!(u8_less_than(choice, 2u8), 1,
+      "aggr structural: discharge choice must be 0 or 1");
+    match choice {
+      0 =>
+        assert_eq!(load(rest), ListNode.Nil,
+          "aggr structural: carried choice has trailing bytes");
+        0,
+      _ =>
+        let (count, path) = aggr_read_byte(rest);
+        assert_eq!(u8_less_than(count, 65u8), 1,
+          "aggr structural: Merkle path exceeds 64 steps");
+        let (actual, stop) = aggr_fold_path(aggr_leaf_hash(candidate),
+          to_field(count), path);
+        assert_eq!(load(stop), ListNode.Nil,
+          "aggr structural: trailing bytes after Merkle path");
+        assert_eq!(address_eq(actual, root), 1,
+          "aggr structural: assumption path does not reach subject root");
+        1,
+    }
+  }
+
+  -- Every unique candidate from `left ∪ right` is either discharged by a
+  -- membership path or consumed from the strictly-sorted output list.
+  fn aggr_assert_structural_difference(left: List‹Addr›, right: List‹Addr›,
+      subject_root: Addr, output: List‹Addr›) {
+    match aggr_next_assumption(left, right) {
+      AggrNextAssumption.Done =>
+        assert_eq!(load(output), ListNode.Nil,
+          "aggr structural: output has an extra assumption");
+        (),
+      AggrNextAssumption.More(candidate, left_rest, right_rest) =>
+        match aggr_discharge_choice(candidate, subject_root) {
+          1 => aggr_assert_structural_difference(left_rest, right_rest,
+            subject_root, output),
+          _ =>
+            let ListNode.Cons(actual, output_rest) = load(output);
+            assert_eq!(address_eq(candidate, actual), 1,
+              "aggr structural: outstanding assumption mismatch");
+            aggr_assert_structural_difference(left_rest, right_rest,
+              subject_root, output_rest),
+        },
+    }
+  }
+
+  fn aggr_get_opt_address(stream: ByteStream) -> (Option‹Addr›, ByteStream) {
+    let (tag, rest) = aggr_read_byte(stream);
+    match tag {
+      0 => (Option.None, rest),
+      1 =>
+        let (addr, stop) = aggr_read_address(rest);
+        (Option.Some(addr), stop),
+    }
+  }
+
+  -- Strictly decode one complete `Claim::CheckEnv` byte string.
+  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 (root, s2) = aggr_read_address(s);
+    let (assumptions, stop) = aggr_get_opt_address(s2);
+    assert_eq!(load(stop), ListNode.Nil,
+      "aggr: trailing bytes after CheckEnv claim");
+    (root, assumptions)
+  }
+
+  /- ## Digest-bound advice and claim decoding -/
+
+  fn aggr_load_preimage(digest: [G; 8]) -> ByteStream {
+    let (idx, len) = io_get_info(4, digest);
+    let bytes = #read_byte_stream(4, idx, len);
+    assert_eq!(@b3_pack(@blake3(bytes)), digest,
+      "aggr: claim preimage digest mismatch");
+    bytes
+  }
+
+  fn aggr_claim_field(claim: List‹U64›, index: G) -> G {
+    @gl_val(list_lookup(claim, index))
+  }
+
+  fn aggr_claim_digest(claim: List‹U64›, start: G) -> [G; 8] {
+    [aggr_claim_field(claim, start),
+     aggr_claim_field(claim, start + 1),
+     aggr_claim_field(claim, start + 2),
+     aggr_claim_field(claim, start + 3),
+     aggr_claim_field(claim, start + 4),
+     aggr_claim_field(claim, start + 5),
+     aggr_claim_field(claim, start + 6),
+     aggr_claim_field(claim, start + 7)]
+  }
+
+  fn aggr_assert_digest(actual: [G; 8], expected: [G; 8]) {
+    assert_eq!(actual[0], expected[0]);
+    assert_eq!(actual[1], expected[1]);
+    assert_eq!(actual[2], expected[2]);
+    assert_eq!(actual[3], expected[3]);
+    assert_eq!(actual[4], expected[4]);
+    assert_eq!(actual[5], expected[5]);
+    assert_eq!(actual[6], expected[6]);
+    assert_eq!(actual[7], expected[7]);
+    ()
+  }
+
+  fn aggr_only_claim(claims: List‹List‹U64››) -> List‹U64› {
+    let ListNode.Cons(claim, rest) = load(claims);
+    assert_eq!(load(rest), ListNode.Nil,
+      "aggr: child proof must expose exactly one claim");
+    claim
+  }
+
+  /- ## Heterogeneous child verification
+
+  Child kind 0 verifies against the IxVM system, kind 1 against this circuit's
+  own system.  Which system a proof MUST verify against is fixed by the kind:
+  the vk bytes on channel 1 are digest-checked against the corresponding half
+  of the allowed blob before deserialization, so a hinted kind that does not
+  match the child proof fails verification.
+  -/
+
+  fn aggr_load_sys(kind: G, ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8])
+      -> Sys {
+    let (sidx, slen) = io_get_info(1, [kind]);
+    let sbytes = #read_byte_stream(1, sidx, slen);
+    let digest = @b3_pack(@blake3(sbytes));
+    match kind {
+      0 =>
+        aggr_assert_digest(digest, ixvm_vk_digest),
+      _ =>
+        aggr_assert_digest(digest, self_vk_digest),
+    };
+    let (sys, srest) = @read_system(sbytes);
+    assert_eq!(load(srest), ListNode.Nil);
+    sys
+  }
+
+  -- Verify one child proof against `sys`. The verified proof's lookup
+  -- accumulator and Fiat-Shamir transcript bind `cbytes` directly, so child
+  -- claims need no standalone public digest.
+  fn aggr_verify_child(sys: Sys, key: G) -> List‹List‹U64›› {
+    let (idx, len) = io_get_info(0, [key]);
+    let (proof, stop) = @read_proof(idx);
+    assert_eq!(stop, idx + len);
+    let (cidx, clen) = io_get_info(2, [key]);
+    let cbytes = #read_byte_stream(2, cidx, clen);
+    let (claims, crest) = @read_claims(cbytes);
+    assert_eq!(load(crest), ListNode.Nil);
+    assert_eq!(@verify(proof), 1);
+    assert_eq!(@ood_verify(sys, proof, claims, cbytes), 1);
+    claims
+  }
+
+  -- Verify the child at `key` as the hinted `kind` and return the packed
+  -- digest of its `CheckEnv` claim bytes.
+  --
+  -- * kind 0 (IxVM): the 10-word `verify_claim` claim carries the `CheckEnv`
+  --   digest as its public input.
+  -- * kind 1 (self): the 18-word `ix_aggr` claim must bind THIS aggregation
+  --   identity (`allowed_digest`), pinning both vks and both entrypoint
+  --   indices transitively; its output digest is the child's `CheckEnv`.
+  fn aggr_child_check_env_digest(kind: G, key: G,
+      ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8],
+      verify_idx: G, aggr_idx: G, allowed_digest: [G; 8]) -> [G; 8] {
+    let sys = aggr_load_sys(kind, ixvm_vk_digest, self_vk_digest);
+    let claim = aggr_only_claim(aggr_verify_child(sys, key));
+    assert_eq!(aggr_claim_field(claim, 0), 0,
+      "aggr: child has the wrong claim channel");
+    match kind {
+      0 =>
+        assert_eq!(list_length(claim), 10,
+          "aggr: IxVM child must expose a 10-word verify_claim claim");
+        assert_eq!(aggr_claim_field(claim, 1), verify_idx,
+          "aggr: IxVM child has the wrong entrypoint");
+        aggr_claim_digest(claim, 2),
+      _ =>
+        assert_eq!(list_length(claim), 18,
+          "aggr: recursive child must expose an 18-word ix_aggr claim");
+        assert_eq!(aggr_claim_field(claim, 1), aggr_idx,
+          "aggr: recursive child has the wrong entrypoint");
+        aggr_assert_digest(aggr_claim_digest(claim, 2), allowed_digest);
+        aggr_claim_digest(claim, 10),
+    }
+  }
+
+  /- ## Shapes -/
+
+  -- Wrap: one child, output statement identical to the child's. Digest
+  -- equality is byte equality (Blake3), so nothing needs to be opened.
+  fn aggr_wrap(kind: G, ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8],
+      verify_idx: G, aggr_idx: G, allowed_digest: [G; 8],
+      out_claim_digest: [G; 8]) {
+    let child = aggr_child_check_env_digest(kind, 0,
+      ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest);
+    aggr_assert_digest(child, out_claim_digest)
+  }
+
+  -- Pair: two children, canonical set-discharge fold.
+  fn aggr_pair(left_kind: G, right_kind: G,
+      ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8],
+      verify_idx: G, aggr_idx: G, allowed_digest: [G; 8],
+      out_claim_digest: [G; 8]) {
+    let left_digest = aggr_child_check_env_digest(left_kind, 0,
+      ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest);
+    let right_digest = aggr_child_check_env_digest(right_kind, 1,
+      ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest);
+    let (left_root, left_asm) =
+      aggr_parse_check_env(aggr_load_preimage(left_digest));
+    let (right_root, right_asm) =
+      aggr_parse_check_env(aggr_load_preimage(right_digest));
+
+    -- Bind and decode this fold's output claim.
+    let (oidx, olen) = io_get_info(2, [2]);
+    let output_bytes = #read_byte_stream(2, oidx, olen);
+    assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest,
+      "aggr: output claim digest mismatch");
+    let (output_root, output_asm) = aggr_parse_check_env(output_bytes);
+
+    let left_subjects = aggr_load_canonical_tree(left_root);
+    let right_subjects = aggr_load_canonical_tree(right_root);
+    let left_assumptions = aggr_load_optional_tree(left_asm);
+    let right_assumptions = aggr_load_optional_tree(right_asm);
+    let output_subjects = aggr_load_canonical_tree(output_root);
+    let output_assumptions = aggr_load_optional_tree(output_asm);
+
+    aggr_assert_union(left_subjects, right_subjects, output_subjects);
+    aggr_assert_difference(left_assumptions, right_assumptions,
+      output_subjects, output_assumptions);
+    ()
+  }
+
+  -- Structural pair: verify the same heterogeneous child forms, commit to
+  -- subjects with one free-form node hash, and discharge assumptions through
+  -- channel-6 Merkle paths. Only canonical assumption trees are opened.
+  fn aggr_pair_structural(left_kind: G, right_kind: G,
+      ixvm_vk_digest: [G; 8], self_vk_digest: [G; 8],
+      verify_idx: G, aggr_idx: G, allowed_digest: [G; 8],
+      out_claim_digest: [G; 8]) {
+    let left_digest = aggr_child_check_env_digest(left_kind, 0,
+      ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest);
+    let right_digest = aggr_child_check_env_digest(right_kind, 1,
+      ixvm_vk_digest, self_vk_digest, verify_idx, aggr_idx, allowed_digest);
+    let (left_root, left_asm) =
+      aggr_parse_check_env(aggr_load_preimage(left_digest));
+    let (right_root, right_asm) =
+      aggr_parse_check_env(aggr_load_preimage(right_digest));
+
+    let (oidx, olen) = io_get_info(2, [2]);
+    let output_bytes = #read_byte_stream(2, oidx, olen);
+    assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest,
+      "aggr structural: output claim digest mismatch");
+    let (output_root, output_asm) = aggr_parse_check_env(output_bytes);
+
+    let expected_root = aggr_node_hash(left_root, right_root);
+    assert_eq!(address_eq(output_root, expected_root), 1,
+      "aggr structural: output subject root is not nodeHash(left, right)");
+
+    let left_assumptions = aggr_load_optional_tree(left_asm);
+    let right_assumptions = aggr_load_optional_tree(right_asm);
+    let output_assumptions = aggr_load_optional_tree(output_asm);
+    aggr_assert_structural_difference(left_assumptions, right_assumptions,
+      output_root, output_assumptions);
+    ()
+  }
+
+  /- ## Entrypoint -/
+
+  -- Public input is `blake3(allowed_blob) ‖ blake3(output_claim_bytes)`,
+  -- packed four bytes per Goldilocks element.
+  pub fn ix_aggr(allowed_digest: [G; 8], out_claim_digest: [G; 8]) {
+    -- Allowed blob:
+    --   ixvm_vk_digest(32) ‖ verify_idx(u64 LE) ‖
+    --   self_vk_digest(32) ‖ aggr_idx(u64 LE).
+    let (aidx, alen) = io_get_info(3, [0]);
+    assert_eq!(alen, 80,
+      "aggr: allowed blob must be exactly 80 bytes");
+    let allowed_bytes = #read_byte_stream(3, aidx, alen);
+    assert_eq!(@b3_pack(@blake3(allowed_bytes)), allowed_digest,
+      "aggr: allowed blob digest mismatch");
+    let (ixvm_digest_addr, as1) = aggr_read_address(allowed_bytes);
+    let (verify_idx_limb, as2) = @read_u64(as1);
+    let (self_digest_addr, as3) = aggr_read_address(as2);
+    let (aggr_idx_limb, astop) = @read_u64(as3);
+    assert_eq!(load(astop), ListNode.Nil,
+      "aggr: allowed blob must be exactly 80 bytes");
+    let ixvm_vk_digest = aggr_pack_address(ixvm_digest_addr);
+    let self_vk_digest = aggr_pack_address(self_digest_addr);
+    let verify_idx = flatten_u64(verify_idx_limb);
+    let aggr_idx = flatten_u64(aggr_idx_limb);
+
+    -- Shape hint: exactly one advice byte.
+    --   0 = wrap IxVM        1 = wrap self
+    --   2–5 = flat pairs:       2 + 2·left + right
+    --   6–9 = structural pairs: 6 + 2·left + right
+    let (hidx, hlen) = io_get_info(6, [0]);
+    assert_eq!(hlen, 1, "aggr: shape hint must be exactly one byte");
+    let hint = #read_byte_stream(6, hidx, hlen);
+    let (shape, hstop) = aggr_read_byte(hint);
+    assert_eq!(load(hstop), ListNode.Nil,
+      "aggr: trailing bytes after shape hint");
+    match shape {
+      0 => aggr_wrap(0, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      1 => aggr_wrap(1, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      2 => aggr_pair(0, 0, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      3 => aggr_pair(0, 1, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      4 => aggr_pair(1, 0, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      5 => aggr_pair(1, 1, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      6 => aggr_pair_structural(0, 0, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      7 => aggr_pair_structural(0, 1, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      8 => aggr_pair_structural(1, 0, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+      9 => aggr_pair_structural(1, 1, ixvm_vk_digest, self_vk_digest,
+        verify_idx, aggr_idx, allowed_digest, out_claim_digest),
+    }
+  }
+⟧
+
+end Aggr
+
+end
diff --git a/Ix/Aggr/Host.lean b/Ix/Aggr/Host.lean
new file mode 100644
index 000000000..3cc277479
--- /dev/null
+++ b/Ix/Aggr/Host.lean
@@ -0,0 +1,129 @@
+module
+public import Ix.AssumptionTree
+public import Ix.Claim
+public import Std.Data.HashSet
+
+/-!
+# Host-side aggregate statement folding
+
+The circuit rechecks all of this from serialized trees and Merkle paths.
+These helpers give the CLI, tests, and benchmarks one implementation for
+constructing flat and structural outputs plus their channel-5/channel-6
+advice.
+-/
+
+public section
+
+namespace Aggr
+
+/-- A `CheckEnv` statement together with the trees whose roots it commits to.
+Leaf and flat-pair subject trees are canonical; structural pairs use free-form
+root-of-roots subject trees. Assumption trees always remain canonical.
+`assumptions = none` is represented by no tree, never by an empty or
+padding-only serialization. -/
+structure CheckEnvTrees where
+  subjects : Ix.AssumptionTree
+  assumptions : Option Ix.AssumptionTree
+  deriving Repr
+
+namespace CheckEnvTrees
+
+def claim (statement : CheckEnvTrees) : Ix.Claim :=
+  .checkEnv statement.subjects.root (statement.assumptions.map (·.root))
+
+def subjectCount (statement : CheckEnvTrees) : Nat :=
+  statement.subjects.leaves.size
+
+private def canonicalizeAt (label : String) (expected : Address)
+    (tree : Ix.AssumptionTree) : Except String Ix.AssumptionTree := do
+  let some canonical := Ix.AssumptionTree.canonical tree.leaves
+    | throw s!"{label}: tree has no real leaves"
+  if canonical.root != expected then
+    throw s!"{label}: leaves do not reproduce claimed canonical root {expected}"
+  pure canonical
+
+/-- Recover and validate a host statement from a claim plus its content-
+addressed tree map. This is used when binding persisted shard proofs to
+aggregation leaves: the wrapper's claim roots must match canonical trees
+reconstructed from the `.ixe` environment. -/
+def ofClaim (claim : Ix.Claim)
+    (trees : Std.HashMap Address Ix.AssumptionTree) : Except String CheckEnvTrees := do
+  let .checkEnv subjectRoot assumptionRoot? := claim
+    | throw "aggr: expected a CheckEnv claim"
+  let some subjectTree := trees.get? subjectRoot
+    | throw s!"aggr: missing subject tree {subjectRoot}"
+  let subjects ← canonicalizeAt "aggr subjects" subjectRoot subjectTree
+  let assumptions ← match assumptionRoot? with
+    | none => pure none
+    | some assumptionRoot =>
+      let some assumptionTree := trees.get? assumptionRoot
+        | throw s!"aggr: missing assumption tree {assumptionRoot}"
+      pure (some (← canonicalizeAt "aggr assumptions"
+        assumptionRoot assumptionTree))
+  pure { subjects, assumptions }
+
+private def assumptionLeaves (statement : CheckEnvTrees) : Array Address :=
+  statement.assumptions.map (·.leaves) |>.getD #[]
+
+/-- The sorted, deduplicated candidate stream consumed by either discharge
+mode: `assumptionsL ∪ assumptionsR`. -/
+def assumptionCandidates (left right : CheckEnvTrees) : Array Address :=
+  match Ix.AssumptionTree.canonical
+      (assumptionLeaves left ++ assumptionLeaves right) with
+  | none => #[]
+  | some tree => tree.leaves
+
+/-- Canonical pair fold:
+
+`subjects = subjectsL ∪ subjectsR`
+
+`assumptions = (assumptionsL ∪ assumptionsR) ∖ subjects`.
+
+The circuit independently verifies this relation with sorted linear merges;
+the host implementation uses a hash set only to construct the witness. -/
+def join (left right : CheckEnvTrees) : CheckEnvTrees :=
+  let subjectLeaves := left.subjects.leaves ++ right.subjects.leaves
+  let subjects := (Ix.AssumptionTree.canonical subjectLeaves).get!
+  let subjectSet := subjects.leaves.foldl (fun set addr => set.insert addr)
+    ({} : Std.HashSet Address)
+  let remaining := assumptionCandidates left right |>.filter
+    (fun addr => !subjectSet.contains addr)
+  { subjects, assumptions := Ix.AssumptionTree.canonical remaining }
+
+/-- Structural fold. Subjects are committed in O(1) as a free-form node over
+the two child roots. Assumptions retain canonical set semantics and drop
+precisely those candidates for which the resulting subject forest can produce
+a membership path. -/
+def joinStructural (left right : CheckEnvTrees) : CheckEnvTrees :=
+  let subjects := Ix.AssumptionTree.join left.subjects right.subjects
+  let remaining := assumptionCandidates left right |>.filter
+    (fun addr => !subjects.contains addr)
+  { subjects, assumptions := Ix.AssumptionTree.canonical remaining }
+
+/-- One channel-6 choice per structural-pair candidate. `some path` discharges
+the candidate against the structural output root; `none` carries it into the
+output assumption set. -/
+def structuralPathAdvice (left right output : CheckEnvTrees) :
+    Array (Address × Option Ix.Merkle.MerklePath) :=
+  assumptionCandidates left right |>.map fun candidate =>
+    (candidate, output.subjects.merkleProof candidate)
+
+/-- The present trees in channel-5 order for one pair fold. Optional empty
+assumption sets contribute no advice entry. -/
+def adviceTrees (left right output : CheckEnvTrees) : Array Ix.AssumptionTree :=
+  #[left.subjects] ++ left.assumptions.toArray ++
+  #[right.subjects] ++ right.assumptions.toArray ++
+  #[output.subjects] ++ output.assumptions.toArray
+
+/-- Structural pairs never open subject trees. Only the canonical input/output
+assumption trees are needed on channel 5. -/
+def structuralAdviceTrees (left right output : CheckEnvTrees) :
+    Array Ix.AssumptionTree :=
+  left.assumptions.toArray ++ right.assumptions.toArray ++
+    output.assumptions.toArray
+
+end CheckEnvTrees
+
+end Aggr
+
+end
diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean
index 412ad59ea..543861de7 100644
--- a/Ix/Aiur/Protocol.lean
+++ b/Ix/Aiur/Protocol.lean
@@ -25,6 +25,11 @@ opaque toBytes : @& Proof → ByteArray
 @[extern "rs_aiur_proof_of_bytes"]
 opaque ofBytes : @& ByteArray → Proof
 
+/-- Decode an untrusted serialized proof without aborting the process. Store
+and network boundaries must use this variant; `ofBytes` remains for callers
+whose bytes were produced in-process or already validated. -/
+@[extern "rs_aiur_proof_of_bytes_checked"]
+opaque ofBytesChecked : @& ByteArray → Except String Proof
 end Proof
 
 structure CommitmentParameters where
@@ -139,8 +144,10 @@ def proveIxVM (system : @& AiurSystem)
   (proveIxVM' system funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map
     fun r => (r.claim, r.proof, .ofArrays r.ioData r.ioMap)
 
-/-- Prove the MultiStark recursive verifier over raw proof/vk/claims
-    byte blobs. The IO advice buffer is built natively in Rust (see
+/-- Prove the MultiStark recursive verifier over proof-advice/vk/claims
+byte blobs. `proofAdviceBytes` must come from
+`AiurSystem.proofToAdviceBytes`; compact `Proof.toBytes` wire bytes are not
+an in-circuit input. The IO advice buffer is built natively in Rust (see
     `Bytecode.Toplevel.executeMultiStark`); the execute step inside
     the prove routes through the codegen'd verifier
     (`crates/ixvm-codegen/src/aiur_multi_stark.rs`) unless
@@ -151,9 +158,59 @@ def proveIxVM (system : @& AiurSystem)
 @[extern "rs_aiur_multi_stark_prove"]
 opaque proveMultiStark (system : @& AiurSystem)
   (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
-  (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
+  (proofAdviceBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
     Except String (Array G × Proof)
 
+/-- Prove one flat or structural aggregate-first binary join over child
+proof/claim advice. Both proof blobs must come from
+`AiurSystem.proofToAdviceBytes`; compact child `Proof.toBytes` values remain
+the persisted/cache representation. The compact preimage/tree/path blobs are produced by
+`MultiStark.joinPreimagesBlob`, `MultiStark.joinTreesBlob`, and
+`MultiStark.joinPathsBlob`. Malformed
+framing is returned as an error; as with `prove`/`proveMultiStark`, callers
+must supply an accepting execution witness. The final native IO buffer is
+intentionally not marshalled back to Lean. -/
+@[extern "rs_aiur_multi_stark_join_prove"]
+opaque proveMultiStarkJoin (system : @& AiurSystem)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
+  (leftProofAdviceBytes rightProofAdviceBytes recursionVkBytes : @& ByteArray)
+  (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray)
+  (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) :
+    Except String (Array G × Proof)
+
+/-- Prove one `ix_aggr` execution — any shape — over raw child proof/claim
+advice. Both proof blobs must come from `AiurSystem.proofToAdviceBytes`;
+compact `Proof.toBytes` values remain the persisted representation. The
+compact preimage/tree/path blobs are produced by `Aggr.preimagesBlob`,
+`Aggr.treesBlob`, and `Aggr.pathsBlob`; wrap and flat shapes pass empty
+right-child blobs. Malformed framing is returned as an error; as with
+`prove`/`proveMultiStark`, callers must supply an accepting execution
+witness. Only valid when `system` was built from the production
+`Aggr.ixAggr` bytecode (unless `useBytecode` is set). The final native IO
+buffer is intentionally not marshalled back to Lean. -/
+@[extern "rs_aiur_ix_aggr_prove"]
+opaque proveIxAggr (system : @& AiurSystem)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat)
+  (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray)
+  (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray)
+  (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) :
+    Except String (Array G × Proof)
+
+/-- Run the production aggregate-first Stage 2 pipeline natively after Lean
+has compiled the IxVM and `ix_aggr` systems. Rust owns all data-dependent
+orchestration: manifest/environment binding, shard-claim reconstruction,
+statement folding, cache validation, dependency scheduling, recursive advice,
+proving, and persistence. `proofHexes` is one store address per line;
+`cacheFriBytes` is the stable 40-byte recursion-FRI cache identity. Returns the
+persisted root proof address. -/
+@[extern "rs_aiur_stage2_aggregate"]
+opaque aggregateStage2 (ixvmSystem aggrSystem : @& AiurSystem)
+  (envHandle : @& EnvHandle) (manifestPath proofHexes : @& String)
+  (verifyIdx aggrIdx jobs ramBudgetBytes structuralAbove : @& Nat)
+  (directJoins planOnly : Bool) (cacheFriBytes : @& ByteArray)
+  (useCache : Bool) :
+    Except String String
+
 @[extern "rs_aiur_system_prove_addr_with_env"]
 private opaque proveAddrWithEnv' : @& AiurSystem →
   @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
@@ -173,54 +230,190 @@ def proveAddrWithEnv (system : @& AiurSystem)
   (proveAddrWithEnv' system funIdx envHandle addrBytes useBytecode).map
     fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap)
 
+/-- Result of a per-shard prove: the claim's wire bytes, the proof, the
+    projected prover RAM peak of the record that produced it
+    (`AiurSystem::peak_prove_bytes`), and the part count the peak model
+    projects will fit the budget
+    (`AiurSystem::suggested_split_parts`).
+
+    `proof` is `none` exactly when the peak exceeded the budget — a
+    RESULT rather than an error, since the caller's answer is to cut
+    the shard into `suggestedParts` parts and prove those. The count is
+    computed Rust-side because only there does the executed record
+    still exist to read per-circuit heights from; it is optimistic
+    (parts re-execute dependencies shared across the cut), so each part
+    must still be gated on its own record. `suggestedParts` is 1
+    whenever the prove ran. The claim bytes are filled either way (the
+    claim is known before proving starts).
+
+    The final IO buffer is not returned — it is the shard's whole
+    ingested byte scope and no caller reads it. -/
+structure ShardProveResult where
+  claimBytes : ByteArray
+  proof : Option Proof
+  peakBytes : Nat
+  suggestedParts : Nat
+
 @[extern "rs_aiur_system_shard_prove_with_env"]
 private opaque shardProveWithEnv' : @& AiurSystem →
-  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray →
-    Except String ProveEnvResult
-
-/-- Per-shard prove against a Rust-owned `EnvHandle`. -/
+  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → Bool →
+    Except String ShardProveResult
+
+/-- Per-shard prove against a Rust-owned `EnvHandle`: ONE execution,
+    whose record is proven from directly.
+
+    `maxRamBytes` is a per-shard prover-RAM budget checked against that
+    record's projected peak before the witness phase begins; `0` means
+    detect (85% of `MemAvailable`, the policy the check batch's RAM gate
+    uses), and an unreadable `/proc/meminfo` disables the check rather
+    than guessing. Over budget, the record is dropped and `proof` is
+    `none` — learning that here costs one execution instead of an OOM
+    part-way through an FFT. The peak comes back either way, so a prove
+    run yields the same split/merge signal a check run does.
+
+    `execOnly` stops after execution + measurement (`proof` is `none`
+    either way; `suggestedParts` is 1 exactly when the peak fits): the
+    split loop runs on executions alone, never starting a STARK. -/
 def shardProveWithEnv (system : @& AiurSystem)
-  (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) :
-    Except String (ByteArray × Proof × IOBuffer) :=
-  (shardProveWithEnv' system funIdx envHandle ownedBlob).map
-    fun r => (r.claimBytes, r.proof, .ofArrays r.ioData r.ioMap)
+  (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
+  (ownedBlob : ByteArray) (maxRamBytes : Nat := 0)
+  (execOnly : Bool := false) :
+    Except String ShardProveResult :=
+  shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes execOnly
 
 @[extern "rs_aiur_system_verify"]
 opaque verify : @& AiurSystem →
   @& Array G → @& Proof → Except String Unit
 
+/-- The proof re-encoded in the per-query advice transport the in-circuit
+verifier consumes (pruned FRI multiproofs expanded to one authentication
+path per query); errors if the proof does not verify natively. -/
+@[extern "rs_aiur_proof_to_advice_bytes"]
+opaque proofToAdviceBytes : @& AiurSystem →
+  @& Array G → @& Proof → Except String ByteArray
+
 end AiurSystem
 
+/-- Write a `.ixes` manifest for an EXPLICIT partition — the block lists
+    a run actually produced (splits included) rather than a planner's
+    output. `shardsBlob`: per shard, a 4-byte LE block count followed by
+    that many 32-byte block addresses; every env block must appear in
+    exactly one shard. `peaksBlob`: one 8-byte LE measured prover peak
+    per shard in order, recorded on the manifest for schedulers. Own
+    sizes, foreign blocks, cross-ingress and assumption roots are
+    recomputed from the env's static profile; prints the manifest
+    summary to stderr. -/
+@[extern "rs_shard_manifest_from_partition"]
+opaque shardManifestFromPartition : @& EnvHandle →
+  @& ByteArray → @& ByteArray → @& String → IO Unit
+
+/-- Refine an existing `.ixes` manifest (`sourcePath`) by cutting some of
+    its leaves into parts and write the result to `outPath`
+    (`ShardManifest::refine`, `crates/kernel/src/shard.rs`). Every other
+    leaf keeps its block list, record, id and place in the aggregation
+    tree; a refined leaf's place becomes a balanced subtree over its
+    parts, part 0 keeps the leaf's id and later parts take fresh ids after
+    the last existing one.
+
+    `refinementsBlob`: `count(u32)`, then per refined leaf `id(u32) ‖
+    nparts(u32)` and per part `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`.
+    `measuredBlob`: empty, or one `u64` analytic prover peak per SOURCE
+    shard in id order; a nonzero value overrides the peak carried forward
+    for an unsplit leaf. The new partition is validated as an exact,
+    disjoint cover of the env's blocks. Returns the parts' new ids:
+    `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. -/
+@[extern "rs_shard_manifest_refine"]
+opaque shardManifestRefine : @& EnvHandle → @& String →
+  @& ByteArray → @& ByteArray → @& String → IO ByteArray
+
+@[extern "rs_aiur_detected_ram_budget"]
+private opaque detectedRamBudgetFFI : IO UInt64
+
+/-- The prover/execution RAM budget the Rust side detects on this machine:
+    85 % of `MemAvailable` (`ix_kernel::shard::RAM_USABLE_FRAC`) — the policy
+    the check batch's RAM gate and `ix prove --max-ram 0` use. `0` when
+    `/proc/meminfo` is unreadable; callers that need a budget fail closed
+    on it instead of running ungated. -/
+def detectedRamBudgetBytes : IO Nat := do
+  pure (← detectedRamBudgetFFI).toNat
+
 namespace Bytecode.Toplevel
 
+/-- One shard's result from `shardCheckBatchWithEnv`. `weights` is the
+    shard's per-constant virtual-gas table, packed as 48-byte rows —
+    32-byte address, then `vspan` and `mult` as little-endian `UInt64`s
+    (see `ShardResult.foldWeights`). Empty unless the batch ran with
+    `profile := true`; the record it is read from is reduced to these
+    rows and dropped inside the shard's own task, so a whole partition's
+    weights fit in RAM when its records could not. -/
+structure ShardResult where
+  error : String
+  peakBytes : Nat
+  weights : ByteArray
+  /-- 1 when `peakBytes` fits the batch's `maxRamBytes` (or no budget
+      was given); otherwise the part count the peak model projects will
+      fit (`AiurSystem::suggested_split_parts`, measured on the record
+      in-task). -/
+  suggestedParts : Nat
+  deriving Inhabited
+
+/-- Bytes per packed `weights` row: 32 address + 8 vspan + 8 mult. -/
+def shardWeightRow : Nat := 48
+
+/-- Fold `f` over the packed `(addrBytes, vspan, mult)` rows of `weights`.
+    Trailing bytes that do not complete a row are ignored. -/
+@[inline] def ShardResult.foldWeights {α : Type} (r : ShardResult) (init : α)
+    (f : α → ByteArray → UInt64 → UInt64 → α) : α :=
+  go (r.weights.size / shardWeightRow) 0 init
+where
+  go : Nat → Nat → α → α
+    | 0, _, acc => acc
+    | rows + 1, off, acc =>
+      go rows (off + shardWeightRow) <| f acc
+        (r.weights.extract off (off + 32))
+        (r.weights.extract (off + 32) (off + 40)).toUInt64LE!
+        (r.weights.extract (off + 40) (off + 48)).toUInt64LE!
+
 @[extern "rs_aiur_toplevel_shard_check_batch"]
 private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel →
   @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat →
-  @& CommitmentParameters → @& FriParameters →
-    Except String (Array (String × Nat))
+  @& CommitmentParameters → @& FriParameters → Bool → @& Nat → @& Nat →
+    Except String (Array ShardResult)
 
 /-- Check EVERY shard of a partition in one call: rayon over the shard
     list with true work-stealing (no chunk barriers), each shard
     through the exact single-shard machinery over its own private
     record and witness io. `shardsBlob` encodes, per shard, a 4-byte LE
     owned-constant count followed by that many 32-byte addresses.
-    Returns one `(error, peakBytes)` pair per shard in shard order:
-    empty error = clean, and `peakBytes` is the analytic prover RAM
-    peak ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's
-    executed record — the split/merge input (0 on failure).
+    Returns one `ShardResult` per shard in shard order: empty error =
+    clean, and `peakBytes` is the analytic prover RAM peak
+    ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's executed
+    record — the split/merge input (0 on failure). `profile` turns on the
+    virtual-gas meter and fills each result's `weights` with the shard's
+    per-constant cost rows, read off the record inside the shard's own
+    task; `checkConstIdx` names the `check_const` function whose queries
+    those rows come from (ignored when not profiling).
     `jobs = 0` uses rayon's default pool width (all cores): peak RSS
     is bounded by the Rust-side RAM gate (a byte-weighted admission
     semaphore over estimated per-shard execution RSS vs available
     system RAM), not by thread count — pass `jobs` only to narrow
-    CPU use. -/
+    CPU use.
+
+    `maxRamBytes > 0` is a per-shard prover-RAM budget: each result's
+    `suggestedParts` is 1 when its peak fits and the model's projected
+    part count otherwise, so a caller can cut over-budget shards and
+    re-batch the parts — the wave loop that audits a partition's split
+    behavior on executions alone. -/
 def shardCheckBatchWithEnv (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
   (shardsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0)
   (commitmentParameters : CommitmentParameters := defaultCommitmentParameters)
   (friParameters : FriParameters := defaultFriParameters)
-  : Except String (Array (String × Nat)) :=
+  (profile : Bool := false) (checkConstIdx : Nat := 0)
+  (maxRamBytes : Nat := 0)
+  : Except String (Array ShardResult) :=
   shardCheckBatchWithEnv' toplevel funIdx envHandle shardsBlob useBytecode
-    jobs commitmentParameters friParameters
+    jobs commitmentParameters friParameters profile checkConstIdx maxRamBytes
 
 end Bytecode.Toplevel
 
diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean
index e699b165a..c04e56840 100644
--- a/Ix/Aiur/Semantics/BytecodeFfi.lean
+++ b/Ix/Aiur/Semantics/BytecodeFfi.lean
@@ -75,14 +75,61 @@ structure QueryCount where
   totalHits : Nat
   deriving Inhabited
 
+-- ===========================================================================
+-- QueryRecordHandle: the execution's Rust-owned `QueryRecord` exposed to
+-- Lean as an opaque handle inside every `ExecuteResult`. Lean inspects
+-- queries with its higher-level knowledge (fn names via `nameMap`,
+-- layouts, addr→name maps) through the accessors below; the record —
+-- the dominant RAM consumer of an execution — frees when Lean drops it.
+-- ===========================================================================
+
+private opaque QueryRecordHandleNonempty : NonemptyType
+def QueryRecordHandle : Type := QueryRecordHandleNonempty.type
+instance : Nonempty QueryRecordHandle := QueryRecordHandleNonempty.property
+
+namespace QueryRecordHandle
+
+/-- Number of query entries registered for function `funIdx`. -/
+@[extern "rs_aiur_qr_fn_len"]
+opaque fnLen : @& QueryRecordHandle → (funIdx : @& Nat) → Nat
+
+/-- Input tuple of entry `i` of function `funIdx` (empty when out of
+    range). Entries are in insertion order; iterate within `fnLen`. -/
+@[extern "rs_aiur_qr_fn_key"]
+opaque fnKey : @& QueryRecordHandle → (funIdx i : @& Nat) → Array G
+
+/-- Multiplicity of entry `i` of function `funIdx`. `0` marks an
+    unconstrained hint row (or an out-of-range index). -/
+@[extern "rs_aiur_qr_fn_mult"]
+opaque fnMult : @& QueryRecordHandle → (funIdx i : @& Nat) → Nat
+
+/-- Recorded virtual-gas span of entry `i` of function `funIdx` — the
+    entry's standalone cost, with memo hits replaying the callee's
+    recorded span. `0` unless the execution ran with `profile := true`
+    (the `Full` execution wrappers' trailing flag). -/
+@[extern "rs_aiur_qr_fn_vspan"]
+opaque fnVspan : @& QueryRecordHandle → (funIdx i : @& Nat) → Nat
+
+/-- Stored values of entry `ptr` in the `memory[size]` map — the deref
+    of an Aiur `&[T; size]` pointer (empty when unbound). E.g. an
+    `Addr = &[U8; 32]` argument derefs to its 32 blake3 bytes via
+    `memKey 32 ptr`. -/
+@[extern "rs_aiur_qr_mem_key"]
+opaque memKey : @& QueryRecordHandle → (size ptr : @& Nat) → Array G
+
+end QueryRecordHandle
+
 /-- Result of an execution FFI call, built directly by Rust
 (`LeanAiurExecuteResult` in `crates/ffi/src/lean.rs`). `ioData`/`ioMap`
-are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. -/
+are the flattened `IOBuffer`; see `IOBuffer.ofArrays`. `record` owns the
+execution's `QueryRecord` — drop the `ExecuteResult` (or project the
+other fields out) before the next heavy execution to release its RAM. -/
 structure ExecuteResult where
   output : Array G
   ioData : Array (G × Array G)
   ioMap : Array ((G × Array G) × IOKeyInfo)
   queryCounts : Array QueryCount
+  record : QueryRecordHandle
 
 -- ===========================================================================
 -- EnvHandle: Rust-owned `ixon::Env` exposed to Lean as an opaque handle.
@@ -122,6 +169,7 @@ private opaque execute' : @& Bytecode.Toplevel →
   @& Bytecode.FunIdx → @& Array G →
   (ioData : @& Array (G × Array G)) →
   (ioMap : @& Array ((G × Array G) × IOKeyInfo)) →
+  (profile : Bool) →
     Except String ExecuteResult
 
 /-- Executes the bytecode function `funIdx` with the given `args` and `ioBuffer`,
@@ -132,14 +180,24 @@ callers can recover instead of crashing. -/
 def execute (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) :
     Except String (Array G × IOBuffer × Array QueryCount) :=
-  (execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map
+  (execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray false).map
     fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts)
 
+/-- `execute` variant returning the full `ExecuteResult`, including the
+    `QueryRecordHandle` for post-run query inspection. `profile` enables
+    per-entry virtual-span recording (`QueryRecordHandle.fnVspan`). -/
+def executeFull (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer)
+  (profile : Bool := false) :
+    Except String ExecuteResult :=
+  execute' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray profile
+
 @[extern "rs_aiur_toplevel_execute_ixvm"]
 private opaque executeIxVM' : @& Bytecode.Toplevel →
   @& Bytecode.FunIdx → @& Array G →
   (ioData : @& Array (G × Array G)) →
   (ioMap : @& Array ((G × Array G) × IOKeyInfo)) →
+  (profile : Bool) →
     Except String ExecuteResult
 
 /-- IxVM-native execution: same shape as `execute`, but routes the
@@ -153,13 +211,25 @@ private opaque executeIxVM' : @& Bytecode.Toplevel →
 def executeIxVM (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) :
     Except String (Array G × IOBuffer × Array QueryCount) :=
-  (executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray).map
+  (executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray false).map
     fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts)
 
+/-- `executeIxVM` variant returning the full `ExecuteResult`, including
+    the `QueryRecordHandle` for post-run query inspection. `profile`
+    enables per-entry virtual-span recording
+    (`QueryRecordHandle.fnVspan`). -/
+def executeIxVMFull (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer)
+  (profile : Bool := false) :
+    Except String ExecuteResult :=
+  executeIxVM' toplevel funIdx args ioBuffer.data.toArray ioBuffer.map.toArray profile
+
 /-- MultiStark-native execution of `verify_multi_stark_proof`: the IO
     advice buffer (channel 0 = proof, 1 = vk, 2 = claims, key `[0]`
     each) is built natively in Rust from the raw byte blobs — no
     per-byte boxing into Lean `G`s, no buffer marshalling across FFI.
+    `proofAdviceBytes` is the expanded per-query transport returned by
+    `AiurSystem.proofToAdviceBytes`, not compact `Proof.toBytes` wire data.
     `useBytecode` selects the generic Aiur bytecode interpreter over
     the codegen'd verifier (`crates/ixvm-codegen/src/aiur_multi_stark.rs`);
     as with `executeIxVM`, the codegen'd path is only valid when
@@ -171,7 +241,44 @@ def executeIxVM (toplevel : @& Bytecode.Toplevel)
 @[extern "rs_aiur_multi_stark_execute"]
 opaque executeMultiStark (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
-  (proofBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
+  (proofAdviceBytes vkBytes claimBytes : @& ByteArray) (useBytecode : Bool := false) :
+    Except String (Array G × Array QueryCount)
+
+/-- Native execution of either aggregate-first join entrypoint. The two
+child proof-advice blobs (from `AiurSystem.proofToAdviceBytes`), child claims,
+and the fixed vk/output/allowed blobs are passed without
+per-byte Lean field boxing. `preimagesBlob` and `treesBlob` use the compact
+count/key/length framing produced by `MultiStark.joinPreimagesBlob` and
+`MultiStark.joinTreesBlob`; `pathsBlob` carries structural discharge choices.
+Rust expands them directly into IO channels 4–6. As with
+`executeMultiStark`, `useBytecode` selects the generic interpreter over the
+generated production verifier. -/
+@[extern "rs_aiur_multi_stark_join_execute"]
+opaque executeMultiStarkJoin (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G)
+  (leftProofAdviceBytes rightProofAdviceBytes recursionVkBytes : @& ByteArray)
+  (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray)
+  (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) :
+    Except String (Array G × Array QueryCount)
+
+/-- Native execution of the `ix_aggr` aggregation entrypoint. Expanded child
+proof advice (from `AiurSystem.proofToAdviceBytes`), claims, and the fixed
+vk/output/allowed blobs are passed without
+per-byte Lean field boxing; `preimagesBlob`, `treesBlob`, and `pathsBlob` use the compact
+count/key/length framing produced by `Aggr.preimagesBlob` and
+`Aggr.treesBlob` / `Aggr.pathsBlob`. Rust expands them directly into IO
+channels 0–6 (the shape hint and structural paths share channel 6 with
+disjoint key shapes). Wrap shapes pass empty right-child/path blobs —
+the circuit never reads them. As with `executeMultiStark`, `useBytecode`
+selects the generic interpreter over the generated production aggregator,
+and the codegen'd path is only valid when `toplevel` is the production
+`Aggr.ixAggr` bytecode. -/
+@[extern "rs_aiur_ix_aggr_execute"]
+opaque executeIxAggr (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (pubInput : @& Array G) (shape : @& Nat)
+  (leftProofAdviceBytes rightProofAdviceBytes ixvmVkBytes selfVkBytes : @& ByteArray)
+  (leftClaimsBytes rightClaimsBytes outputClaimBytes allowedBytes : @& ByteArray)
+  (preimagesBlob treesBlob pathsBlob : @& ByteArray) (useBytecode : Bool := false) :
     Except String (Array G × Array QueryCount)
 
 -- (EnvHandle opaque type + constructors live above `namespace
@@ -181,7 +288,8 @@ opaque executeMultiStark (toplevel : @& Bytecode.Toplevel)
 
 @[extern "rs_aiur_toplevel_check_addr_with_env"]
 private opaque checkAddrWithEnv' : @& Bytecode.Toplevel →
-  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
+  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray →
+  (useBytecode profile : Bool) →
     Except String ExecuteResult
 
 /-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode`
@@ -193,7 +301,7 @@ def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
   (addrBytes : ByteArray) (useBytecode : Bool := false)
   : Except String (Array G × IOBuffer × Array QueryCount) :=
-  (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode).map
+  (checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode false).map
     fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts)
 
 @[extern "rs_aiur_toplevel_check_addrs_with_env"]
@@ -207,7 +315,8 @@ private opaque checkAddrsWithEnv' : @& Bytecode.Toplevel →
     through the exact single-claim machinery over task-private data
     (own witness io, own query record), nothing shared between tasks
     but the read-only toplevel and env. Returns the FAILURES as
-    `(addrHex, error)` pairs; empty means all passed. Per-claim
+    `(batch index as a decimal string, error)` pairs, resolving back to
+    the caller's label order; empty means all passed. Per-claim
     outputs/records are not returned — use `checkAddrWithEnv` for a
     single claim's full result. -/
 def checkAddrsWithEnv (toplevel : @& Bytecode.Toplevel)
@@ -216,9 +325,21 @@ def checkAddrsWithEnv (toplevel : @& Bytecode.Toplevel)
   : Except String (Array (String × String)) :=
   checkAddrsWithEnv' toplevel funIdx envHandle addrsBlob useBytecode jobs
 
+/-- `checkAddrWithEnv` variant returning the full `ExecuteResult`,
+    including the `QueryRecordHandle` for post-run query inspection.
+    `profile` enables per-entry virtual-span recording
+    (`QueryRecordHandle.fnVspan`). -/
+def checkAddrWithEnvFull (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
+  (addrBytes : ByteArray) (useBytecode : Bool := false)
+  (profile : Bool := false)
+  : Except String ExecuteResult :=
+  checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode profile
+
 @[extern "rs_aiur_toplevel_shard_check_with_env"]
 private opaque shardCheckWithEnv' : @& Bytecode.Toplevel →
-  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool →
+  @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray →
+  (useBytecode profile : Bool) →
     Except String ExecuteResult
 
 /-- Per-shard check with the witness shape (wrapper-augmented byte
@@ -228,9 +349,20 @@ def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel)
   (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
   (ownedBlob : ByteArray) (useBytecode : Bool := false)
   : Except String (Array G × IOBuffer × Array QueryCount) :=
-  (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode).map
+  (shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode false).map
     fun r => (r.output, .ofArrays r.ioData r.ioMap, r.queryCounts)
 
+/-- `shardCheckWithEnv` variant returning the full `ExecuteResult`,
+    including the `QueryRecordHandle` for post-run query inspection.
+    `profile` enables per-entry virtual-span recording
+    (`QueryRecordHandle.fnVspan`). -/
+def shardCheckWithEnvFull (toplevel : @& Bytecode.Toplevel)
+  (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle)
+  (ownedBlob : ByteArray) (useBytecode : Bool := false)
+  (profile : Bool := false)
+  : Except String ExecuteResult :=
+  shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode profile
+
 end Bytecode.Toplevel
 
 end Aiur
diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean
index 3bf36a95a..5c60b659a 100644
--- a/Ix/Aiur/Stages/Codegen.lean
+++ b/Ix/Aiur/Stages/Codegen.lean
@@ -384,24 +384,34 @@ private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx)
   -- always skipped; when opUn = false both expressions collapse to
   -- just `unconstrained`.
   let cuExpr : String := if opUn then "true" else "unconstrained"
-  let bumpCond : String := if opUn then "false" else "!unconstrained"
+  -- On a constrained hit, `replay_at` bumps the multiplicity and returns
+  -- the entry's virtual-gas replay cost (its recorded standalone span
+  -- when profiling, else the map weight) to add to `record.virt`.
   let bumpStmt : String :=
     if opUn then ""
-    else s!" if {bumpCond} \{ *result.multiplicity += G::ONE; }"
+    else
+      s!" if !unconstrained \{ let __r = record.function_queries[{callee}].replay_at(__i); record.virt += __r; }"
   -- Skip `try_into().unwrap()` on the cache hit: we statically know
   -- the cached output has exactly `OUT_{callee}` elements (only we
   -- ever insert into this slot via the matching aiur_fn_{callee}
   -- `Ctrl::Return`). An unchecked array copy is sound.
   let retExpr : String :=
-    s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(result.output.as_ptr() as *const [G; OUT_{callee}]) }; __ret"
+    s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(record.function_queries[{callee}].output_at(__i).as_ptr() as *const [G; OUT_{callee}]) }; __ret"
+  -- A zero-multiplicity entry was computed only as an unconstrained
+  -- hint; a constrained caller replays the body (constrained: `__cu` is
+  -- false on that path) so promotion recurses through the whole
+  -- dependency tree. Mirrors execute.rs Op::Call.
+  let hitGuard : String :=
+    if opUn then "true"
+    else
+      s!"__cu || record.function_queries[{callee}].mult_at(__i) != G::ZERO"
   let blockExpr : String :=
     s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++
     s!" let __cu = {cuExpr};" ++
-    s!" if let Some(result) = record.function_queries[{callee}].get_mut(&__args[..]) \{" ++
-    s!" if !__cu && *result.multiplicity == G::ZERO \{" ++
-    s!" aiur_fn_{callee}(__args, record, io_buffer, false)?" ++
-    s!" } else \{" ++ bumpStmt ++ retExpr ++ " }" ++
-    s!" } else \{ aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }"
+    s!" let __hit = record.function_queries[{callee}].get_index_of(&__args[..]);" ++
+    s!" match __hit \{ Some(__i) if {hitGuard} => \{" ++
+    bumpStmt ++ retExpr ++ " }," ++
+    s!" _ => aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }"
   let mut stmts : Array RustStmt := #[
     .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr)
   ]
@@ -417,12 +427,13 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt :=
   let blockExpr : String :=
     s!"\{ let __values: [G; {size}] = {valsStr};" ++
     s!" let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++
-    s!" if let Some(result) = __mq.get_mut(&__values[..]) \{" ++
-    s!" if !unconstrained \{ *result.multiplicity += G::ONE; }" ++
-    s!" result.output[0]" ++
+    s!" if let Some(__i) = __mq.get_index_of(&__values[..]) \{" ++
+    s!" if !unconstrained \{ let __r = __mq.replay_at(__i); record.virt += __r; }" ++
+    s!" __mq.output_at(__i)[0]" ++
     s!" } else \{" ++
     s!" let __ptr = G::from_usize(__mq.len());" ++
-    s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }"
+    s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained));" ++
+    s!" if !unconstrained \{ record.virt += __mq.weight(); } __ptr } }"
   #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)]
 
 /-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer
@@ -432,8 +443,9 @@ private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt :=
     s!"\{ let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++
     s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++
     s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++
-    s!" let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++
-    s!" if !unconstrained \{ *__mult += G::ONE; }" ++
+    s!" if __ptr_usize >= __mq.len() \{ return Err(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} }); }" ++
+    s!" if !unconstrained \{ let __r = __mq.replay_at(__ptr_usize); record.virt += __r; }" ++
+    s!" let (__args, _) = __mq.get_index(__ptr_usize).expect(\"bounds checked above\");" ++
     s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }"
   let mut stmts : Array RustStmt := #[
     .letStmt false "__loaded" (some s!"[G; {size}]") (.lit blockExpr)
@@ -817,13 +829,12 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String)
     let outArr : RustStmt :=
       .letStmt false "__ret" (some s!"[G; OUT_{funIdx}]")
         (.arrayLit (outs.map valVar))
+    -- `finish` inserts / promotes the row, and (when profiling)
+    -- records the frame's virtual span measured against the `__vsnap`
+    -- taken at fn entry. Own-row touch priced before the span is read.
     let insertCall : RustStmt := .exprStmt (.lit <|
-      s!"if let Some(result) = record.function_queries[{funIdx}].get_mut(&inp[..]) \{" ++
-      " debug_assert_eq!(result.output, &__ret[..]);" ++
-      " if !unconstrained { *result.multiplicity += G::ONE; }" ++
-      " } else {" ++
-      s!" record.function_queries[{funIdx}].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained));" ++
-      " }")
+      s!"if !unconstrained \{ record.virt += record.function_queries[{funIdx}].weight(); }" ++
+      s!" record.function_queries[{funIdx}].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap)")
     -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>.
     return #[outArr, insertCall,
       .returnStmt (.call (.var "Ok") #[.var "__ret"])]
@@ -938,6 +949,9 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do
     s!"  unconstrained: bool,\n" ++
     s!") -> Result<[G; OUT_{funIdx}], ExecError> {lbrace}\n" ++
     s!"  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {lbrace}\n" ++
+    -- Virtual-gas snapshot at frame entry; `Ctrl::Return` records the
+    -- frame's span (`record.virt - __vsnap`) on the registered query.
+    s!"  let __vsnap = record.virt;\n" ++
     bodyText ++
     s!"  {rbrace})\n" ++
     s!"{rbrace}\n\n"
diff --git a/Ix/Aiur/Statistics.lean b/Ix/Aiur/Statistics.lean
index 9ff9200c6..aa91de166 100644
--- a/Ix/Aiur/Statistics.lean
+++ b/Ix/Aiur/Statistics.lean
@@ -53,19 +53,6 @@ structure ExecutionStats where
   totalCacheHits : Nat
   deriving Inhabited
 
-/-- Coarse PROVER RAM projection for a record with these circuit
-    heights: the committed trace bytes over the LDE domain,
-    `Σ nextPowerOfTwo(height) · committedWidth · 8 · 2^logBlowup`, with empty
-    circuits contributing nothing (the prover deactivates them). A
-    surrogate for relative shard sizing — how many shards must split
-    (over a prover budget) or could merge (far under it) — not an
-    exact allocator-level peak. -/
-def ExecutionStats.projectedProverBytes (stats : ExecutionStats)
-    (logBlowup : Nat := defaultCommitmentParameters.logBlowup) : Nat :=
-  stats.circuits.foldl (init := 0) fun acc c =>
-    if c.height == 0 then acc
-    else acc + Nat.nextPowerOfTwo c.height * c.width * 8 * (2 ^ logBlowup)
-
 /-- Continuous transform-size surrogate: `0` at `0` (an empty circuit is
 deactivated by the prover), else `x·log2(max(x, 2))` — the clamp keeps a
 height-1 transform nonzero. -/
diff --git a/Ix/Cli/AggregateCmd.lean b/Ix/Cli/AggregateCmd.lean
new file mode 100644
index 000000000..e081ac716
--- /dev/null
+++ b/Ix/Cli/AggregateCmd.lean
@@ -0,0 +1,1205 @@
+/-
+  `ix aggregate --ixe E --ixes M <shard-proof>...`
+
+  Bind persisted shard proof wrappers to every nonempty shard in a manifest,
+  wrap each IxVM proof into the single-entrypoint `ix_aggr` recursion system,
+  then execute/prove binary folds in the manifest's bisection-tree order.
+  Small folds use flat canonical subjects; folds above `--structural-above`
+  use an O(1) root-of-roots subject fold plus assumption-membership paths.
+  `--direct-joins` keeps raw IxVM leaves until their first parent as an
+  explicitly non-default policy. The final persisted wrapper carries the
+  aggregate `CheckEnv` claim and recursive proof bytes.
+
+  The host driver schedules the fold as a dependency DAG. Ready slots run on
+  dedicated tasks under explicit job and RAM reservations; every completed
+  wrap/fold is persisted in a verified, content-addressed resume cache.
+-/
+module
+import Std.Sync
+public import Cli
+public import Ix.Aggr
+public import Ix.Cli.CheckCmd
+public import Ix.IxVM
+public import Ix.IxVM.ClaimHarness
+public import Ix.MultiStark
+public import Ix.Store
+
+public section
+
+namespace Ix.Cli.AggregateCmd
+
+open IxVM.ClaimHarness
+
+structure PreparedShard where
+  claim : Ix.Claim
+  statement : MultiStark.CheckEnvTrees
+
+structure AggregateSlot where
+  /-- Which verifying system a parent must use for this slot. Production
+  wrap-first slots are all `.aggr`; direct-join leaf slots remain `.ixvm`. -/
+  kind : Aggr.ChildKind := .aggr
+  statement : MultiStark.CheckEnvTrees
+  subjectCount : Nat
+  outerClaim : Array Aiur.G
+  proof : Aiur.Proof
+  proofAddress? : Option Address
+  /-- Serialized singleton outer-claim list consumed by a parent. -/
+  claimsBytes : ByteArray := ByteArray.empty
+
+/-- Everything claim-derived about a slot, computed for the whole fold before
+the first cache lookup or proof. -/
+structure AggregateSlotSpec where
+  kind : Aggr.ChildKind := .aggr
+  statement : MultiStark.CheckEnvTrees
+  subjectCount : Nat
+  outerClaim : Array Aiur.G
+  cacheKey : Address
+
+structure CachedAggregateProof where
+  proof : Aiur.Proof
+  address : Address
+
+inductive AggregateCacheAddress where
+  | miss
+  | hit (address : Address)
+  | invalid (reason : String)
+  deriving Repr
+
+/-- A manifest fold operation annotated with the cumulative subject count and
+the monotone flat/structural choice used by the prover. -/
+structure ScheduledFold where
+  op : Ix.Cli.CheckCmd.AggregationTree.FoldOp
+  subjectCount : Nat
+  structural : Bool
+  /-- Result kind of this slot. Only direct-policy leaves are `.ixvm`. -/
+  kind : Aggr.ChildKind := .aggr
+  /-- `ix_aggr` shape proven by this slot. Direct-policy raw leaves have no
+  shape because they are verified and forwarded without a recursion proof. -/
+  shape? : Option Nat := none
+  deriving BEq, Repr
+
+/-- The immutable result of simulating aggregate-slot admission. Runtime and
+unit tests share the same admission function; the simulator completes the
+lowest-numbered in-flight slot after every admission pass solely to make its
+trace deterministic. -/
+structure AggregateScheduleTrace where
+  admissionOrder : Array Nat
+  admissionBatches : Array (Array Nat)
+  maxReservedBytes : Nat
+  deriving BEq, Repr
+
+def defaultStructuralAbove : Nat := 4096
+
+def aggregateGiB : Nat := 1024 * 1024 * 1024
+
+/-- Calibration-pending q=100 lift reserve from the measured §3.2 upper
+bound. A slot heavier than the configured budget is admitted only by itself,
+matching the existing Rust-side `RamGate` and avoiding deadlock. -/
+def aggregateLiftRamBytes : Nat := 195 * aggregateGiB
+
+/-- M1 name for shape-0 wrap cost. Keep the lift alias above while the
+benchmark/test union is migrated in M1-e/M1-f. -/
+def aggregateWrapRamBytes : Nat := aggregateLiftRamBytes
+
+/-- Structural joins are dominated by the same two recursive-proof checks as
+lifts. Keep the conservative lift reserve until the real E2E calibration. -/
+def aggregateStructuralJoinRamBytes : Nat := aggregateLiftRamBytes
+
+/-- Native verification and forwarding of a raw shard proof in direct mode.
+The expensive proof-advice expansion is charged to its consuming pair. -/
+def aggregateRawShardRamBytes : Nat := 4 * aggregateGiB
+
+/-- Measured upper envelope for an `IxVM + IxVM` pair (shapes 2/6). -/
+def aggregateDirectJoinRamBytes : Nat := 390 * aggregateGiB
+
+/-- Measured upper envelope for a mixed recursive/IxVM pair (shapes 3/4/7/8). -/
+def aggregateMixedJoinRamBytes : Nat := 340 * aggregateGiB
+
+/-- Flat joins add canonical subject-tree work to the recursive-proof base.
+One MiB per subject is a deliberately conservative placeholder: at Init's
+~52k-subject root it adds ~51 GiB, consistent with the §11.4 estimate. The
+default structural threshold caps this term near 4 GiB in production. -/
+def aggregateFlatJoinRamPerSubjectBytes : Nat := 1024 * 1024
+
+/-- Per-shape RAM weight used by the Lean admission gate. Shape 5 retains the
+flat subject-count reserve; shape 9 is the O(1)-subject structural arm. The
+direct/mixed values are conservative round-ups of the §3.4 measurements. -/
+def aggregateShapeRamBytes (shape subjectCount : Nat) : Nat :=
+  match shape with
+  | 0 | 1 => aggregateWrapRamBytes
+  | 2 | 6 => aggregateDirectJoinRamBytes
+  | 3 | 4 | 7 | 8 => aggregateMixedJoinRamBytes
+  | 5 => aggregateStructuralJoinRamBytes +
+      subjectCount * aggregateFlatJoinRamPerSubjectBytes
+  | 9 => aggregateStructuralJoinRamBytes
+  | _ => aggregateDirectJoinRamBytes
+
+/-- Calibration-pending per-slot RAM weight used by the Lean admission gate.
+The `none` fallback preserves the pre-M1 meaning of hand-built test plans. -/
+def aggregateSlotRamBytes (item : ScheduledFold) : Nat :=
+  match item.shape? with
+  | some shape => aggregateShapeRamBytes shape item.subjectCount
+  | none => match item.op with
+    | .leaf _ => if item.kind == .ixvm then aggregateRawShardRamBytes
+        else aggregateWrapRamBytes
+    | .join _ _ =>
+      if item.structural then aggregateStructuralJoinRamBytes
+      else aggregateStructuralJoinRamBytes +
+        item.subjectCount * aggregateFlatJoinRamPerSubjectBytes
+
+def aggregateSlotRamWeights (plan : Array ScheduledFold) : Array Nat :=
+  plan.map aggregateSlotRamBytes
+
+private def aggregateScheduleInputsValid (plan : Array ScheduledFold)
+    (weights : Array Nat) : Except String Unit := do
+  if weights.size != plan.size then
+    throw s!"aggregate scheduler received {weights.size} weights for {plan.size} slots"
+  for (item, slotIdx) in plan.mapIdx fun slotIdx item => (item, slotIdx) do
+    if weights[slotIdx]! == 0 then
+      throw s!"aggregate scheduler slot {slotIdx} has zero RAM weight"
+    match item.op with
+    | .leaf _ => pure ()
+    | .join left right =>
+      if left >= slotIdx || right >= slotIdx then
+        throw s!"aggregate scheduler slot {slotIdx} has non-prior child {left}, {right}"
+
+private def aggregateDependenciesComplete (item : ScheduledFold)
+    (completed : Array Bool) : Bool :=
+  match item.op with
+  | .leaf _ => true
+  | .join left right =>
+    (completed[left]?).getD false && (completed[right]?).getD false
+
+/-- Select one deterministic admission batch from the currently ready slots.
+Candidates are ordered by descending RAM weight, then ascending slot number.
+Slots that do not fit are skipped so lighter work can use the remaining
+budget. An individually oversized slot may run only when nothing else is
+reserved, following the Rust `RamGate` admit-when-alone rule. `jobs = 0`
+means no concurrency cap beyond the number of plan slots. -/
+def admitAggregateReady (plan : Array ScheduledFold) (weights : Array Nat)
+    (completed inFlight : Array Bool) (reservedBytes budgetBytes jobs : Nat) :
+    Array Nat := Id.run do
+  let active := inFlight.count true
+  let maxJobs := if jobs == 0 then max 1 plan.size else max 1 jobs
+  if active >= maxJobs then return #[]
+  let openJobs := maxJobs - active
+  let mut ready : Array Nat := #[]
+  for slotIdx in [:plan.size] do
+    if !(completed[slotIdx]?).getD false &&
+        !(inFlight[slotIdx]?).getD false then
+      if let some item := plan[slotIdx]? then
+        if aggregateDependenciesComplete item completed then
+          ready := ready.push slotIdx
+  ready := ready.qsort fun left right =>
+    let leftWeight := (weights[left]?).getD 0
+    let rightWeight := (weights[right]?).getD 0
+    leftWeight > rightWeight || (leftWeight == rightWeight && left < right)
+  let mut admitted : Array Nat := #[]
+  let mut admittedBytes := 0
+  for slotIdx in ready do
+    if admitted.size >= openJobs then break
+    let weight := (weights[slotIdx]?).getD 0
+    let nextReserved := reservedBytes + admittedBytes + weight
+    if nextReserved <= budgetBytes ||
+        (reservedBytes == 0 && admitted.isEmpty) then
+      admitted := admitted.push slotIdx
+      admittedBytes := admittedBytes + weight
+  return admitted
+
+/-- Pure deterministic exercise of the runtime admission algorithm. This is
+used to gate heaviest-first ordering, dependency release, job caps, and peak
+reservation without starting proof tasks. -/
+def simulateAggregateSchedule (plan : Array ScheduledFold)
+    (weights : Array Nat) (jobs budgetBytes : Nat) :
+    Except String AggregateScheduleTrace := do
+  aggregateScheduleInputsValid plan weights
+  if budgetBytes == 0 then throw "aggregate scheduler RAM budget must be positive"
+  let mut completed := Array.replicate plan.size false
+  let mut inFlight := Array.replicate plan.size false
+  let mut completedCount := 0
+  let mut reservedBytes := 0
+  let mut maxReservedBytes := 0
+  let mut admissionOrder : Array Nat := #[]
+  let mut admissionBatches : Array (Array Nat) := #[]
+  while completedCount < plan.size do
+    let admitted := admitAggregateReady plan weights completed inFlight
+      reservedBytes budgetBytes jobs
+    if !admitted.isEmpty then
+      admissionBatches := admissionBatches.push admitted
+      for slotIdx in admitted do
+        inFlight := inFlight.set! slotIdx true
+        reservedBytes := reservedBytes + weights[slotIdx]!
+        admissionOrder := admissionOrder.push slotIdx
+      maxReservedBytes := max maxReservedBytes reservedBytes
+    let mut finish? : Option Nat := none
+    for slotIdx in [:plan.size] do
+      if finish?.isNone && inFlight[slotIdx]! then finish? := some slotIdx
+    let some finished := finish?
+      | throw "aggregate scheduler deadlocked with unfinished slots"
+    inFlight := inFlight.set! finished false
+    completed := completed.set! finished true
+    reservedBytes := reservedBytes - weights[finished]!
+    completedCount := completedCount + 1
+  pure { admissionOrder, admissionBatches, maxReservedBytes }
+
+private def formatAggregateGiB (bytes : Nat) : String :=
+  let tenths := bytes * 10 / aggregateGiB
+  s!"{tenths / 10}.{tenths % 10}"
+
+/-- Linux `MemTotal` parser kept separate so the 92% default has a pure seam.
+The fallback only affects non-Linux hosts; admit-when-alone still guarantees
+progress without pretending the fallback is a calibrated capacity. -/
+def aggregateMemTotalBytes (contents : String) : Option Nat :=
+  (contents.splitOn "\n").findSome? fun line =>
+    if line.startsWith "MemTotal:" then
+      ((line.splitOn " ").filter (· != "") |>.drop 1).head?.bind fun kib =>
+        kib.toNat?.map (· * 1024)
+    else none
+
+def defaultAggregateRamBudgetBytes : IO Nat := do
+  let contents ← try IO.FS.readFile "/proc/meminfo" catch _ => pure ""
+  return match aggregateMemTotalBytes contents with
+    | some total => total / 100 * 92
+    | none => 16 * aggregateGiB
+
+/-- Bump when aggregate cache identity changes beyond the recursion verifying
+key. Version 2 marks M1's uniform `ix_aggr` outer claims. Encoded as `u64`
+little-endian in every cache key. -/
+def aggregateCacheVersion : Nat := 2
+
+/--
+`blake3(version ‖ recursion_vk_digest ‖ fri_params_ser ‖ outer_claim_bytes)`.
+
+`serializeClaims #[outerClaim]` is the canonical, length-delimited outer-claim
+encoding. The expected outer claim commits to the single entrypoint, allowed
+blob, and output statement at every persisted node.
+-/
+def aggregateCacheKey (recursionVk : ByteArray)
+    (recursionParameters : MultiStark.RecursionParameters)
+    (outerClaim : Array Aiur.G) (version : Nat := aggregateCacheVersion) : Address :=
+  let recursionVkDigest := (Address.blake3 recursionVk).hash
+  let outerClaimBytes := MultiStark.serializeClaims #[outerClaim]
+  Address.blake3 ⟨MultiStark.u64le version ++ recursionVkDigest.data ++
+    recursionParameters.cacheFriBytes.data ++ outerClaimBytes.data⟩
+
+/-- Resolve the global aggregate cache or a hermetic test root. -/
+def aggregateCacheDir (cacheRoot : Option System.FilePath := none) : IO System.FilePath := do
+  match cacheRoot with
+  | some root =>
+    let dir := root / "aggregate"
+    IO.FS.createDirAll dir
+    pure dir
+  | none => StoreIO.toIO (Store.cacheDir "aggregate")
+
+/-- Read an untrusted cache-index entry without turning malformed content into
+a command failure. Store loading and proof verification happen separately. -/
+def readAggregateCacheAddress (dir : System.FilePath) (key : Address) :
+    IO AggregateCacheAddress := do
+  let path := dir / toString key
+  if !(← path.pathExists) then return .miss
+  try
+    let raw ← IO.FS.readFile path
+    match Address.fromString raw.trimAscii.toString with
+    | some address => return .hit address
+    | none => return .invalid "index content is not a 64-character store address"
+  catch e =>
+    return .invalid s!"index read failed: {e}"
+
+/-- Atomically replace one derived cache-index entry. -/
+def writeAggregateCacheAddress (dir : System.FilePath) (key address : Address) :
+    IO Unit := do
+  let tmp := dir / s!"{key}.tmp"
+  IO.FS.writeFile tmp s!"{address}\n"
+  IO.FS.rename tmp (dir / toString key)
+
+/-- A cached wrapper is reusable only when both its bundled `CheckEnv` claim
+and its proof under the exact expected outer Aiur claim validate. -/
+def validateAggregateCacheWrapper (recursionSystem : Aiur.AiurSystem)
+    (expectedClaim : Ix.Claim) (expectedOuterClaim : Array Aiur.G)
+    (wrapper : Ixon.Proof) : Except String Aiur.Proof := do
+  if wrapper.claim != expectedClaim then
+    throw s!"bundled claim {wrapper.claim} does not match expected {expectedClaim}"
+  let proof ← Aiur.Proof.ofBytesChecked wrapper.proof
+  recursionSystem.verify expectedOuterClaim proof
+  pure proof
+
+/-- Resolve subject counts and the structural threshold once, before proving.
+Because parent counts only grow, `count > structuralAbove` makes the mode
+monotone: a flat join is never scheduled above a structural child. -/
+def schedulePlan (plan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp)
+    (shardCounts : Array Nat) (structuralAbove : Nat)
+    (directJoins : Bool := false) :
+    Except String (Array ScheduledFold) := do
+  let mut scheduled : Array ScheduledFold := #[]
+  -- A singleton must still produce an `ix_aggr` wrapper. Larger direct plans
+  -- keep leaves raw so their first pair can select shapes 2–4/6–8.
+  let rawLeaves := directJoins && plan.size > 1
+  for op in plan do
+    match op with
+    | .leaf shard =>
+      let some count := shardCounts[shard]?
+        | throw s!"aggregate plan references missing shard {shard}"
+      let kind := if rawLeaves then Aggr.ChildKind.ixvm else .aggr
+      let shape? := if rawLeaves then none
+        else some (Aggr.shapeCode (.ixvm, none))
+      scheduled := scheduled.push {
+        op, subjectCount := count, structural := false, kind, shape?
+      }
+    | .join left right =>
+      let some leftSlot := scheduled[left]?
+        | throw s!"aggregate plan references missing left slot {left}"
+      let some rightSlot := scheduled[right]?
+        | throw s!"aggregate plan references missing right slot {right}"
+      let count := leftSlot.subjectCount + rightSlot.subjectCount
+      let structural := count > structuralAbove
+      let shape := if structural then
+          Aggr.structuralShapeCode leftSlot.kind rightSlot.kind
+        else
+          Aggr.shapeCode (leftSlot.kind, some rightSlot.kind)
+      scheduled := scheduled.push {
+        op, subjectCount := count, structural, kind := .aggr,
+        shape? := some shape
+      }
+  pure scheduled
+
+/-! ## Converged single-entrypoint slot derivation -/
+
+/-- Convert the old host record used by the scheduler/cache tests into the
+converged host record. Both commit to the same subject and assumption trees. -/
+def toAggrCheckEnvTrees (statement : MultiStark.CheckEnvTrees) :
+    Aggr.CheckEnvTrees :=
+  { subjects := statement.subjects, assumptions := statement.assumptions }
+
+/-- Convert a converged host fold back into the stable driver record while the
+M1-e test union still shares the pre-convergence public structures. -/
+def fromAggrCheckEnvTrees (statement : Aggr.CheckEnvTrees) :
+    MultiStark.CheckEnvTrees :=
+  { subjects := statement.subjects, assumptions := statement.assumptions }
+
+/-- Every persisted aggregate proof now has the same outer claim regardless
+of whether its witness used a wrap, flat pair, or structural pair. -/
+def aggregateOuterClaim (allowed : ByteArray) (aggrIdx : Aiur.Bytecode.FunIdx)
+    (claim : Ix.Claim) : Array Aiur.G :=
+  Aiur.buildClaim aggrIdx (Aggr.pubInput allowed (Ix.Claim.ser claim)) #[]
+
+/-- Derive every converged slot statement, uniform outer claim, kind, and
+cache key before proving. Wrap-first leaves use shape 0; direct-policy leaves
+remain raw IxVM claims and are deliberately not cache-consumed. -/
+def buildAggrSlotSpecs (plan : Array ScheduledFold)
+    (prepared : Array PreparedShard) (aggrVk allowed : ByteArray)
+    (verifyIdx aggrIdx : Aiur.Bytecode.FunIdx)
+    (recursionParameters : MultiStark.RecursionParameters) :
+    Except String (Array AggregateSlotSpec) := do
+  let mut specs : Array AggregateSlotSpec := #[]
+  for item in plan do
+    match item.op with
+    | .leaf shard =>
+      let some preparedShard := prepared[shard]?
+        | throw s!"aggregate plan references missing prepared shard {shard}"
+      if preparedShard.claim != preparedShard.statement.claim then
+        throw s!"prepared shard {shard} claim and statement disagree"
+      if preparedShard.statement.subjectCount != item.subjectCount then
+        throw s!"prepared shard {shard} has {preparedShard.statement.subjectCount} \
+          subjects, but the schedule records {item.subjectCount}"
+      let claimBytes := Ix.Claim.ser preparedShard.claim
+      let verifyInput := IxVM.ClaimHarness.packedDigestKey
+        (Address.blake3 claimBytes)
+      let innerClaim := Aiur.buildClaim verifyIdx verifyInput #[]
+      let outerClaim := match item.kind with
+        | .ixvm => innerClaim
+        | .aggr => aggregateOuterClaim allowed aggrIdx preparedShard.claim
+      match item.kind, item.shape? with
+      | .ixvm, none => pure ()
+      | .aggr, some 0 => pure ()
+      | _, _ => throw s!"aggregate leaf {shard} has inconsistent kind/shape"
+      specs := specs.push {
+        kind := item.kind
+        statement := preparedShard.statement
+        subjectCount := item.subjectCount
+        outerClaim
+        cacheKey := aggregateCacheKey aggrVk recursionParameters outerClaim
+      }
+    | .join leftIdx rightIdx =>
+      let some left := specs[leftIdx]?
+        | throw s!"aggregate plan references missing left spec {leftIdx}"
+      let some right := specs[rightIdx]?
+        | throw s!"aggregate plan references missing right spec {rightIdx}"
+      if left.subjectCount + right.subjectCount != item.subjectCount then
+        throw "aggregate plan has inconsistent joined subject counts"
+      let leftAggr := toAggrCheckEnvTrees left.statement
+      let rightAggr := toAggrCheckEnvTrees right.statement
+      let outputAggr := if item.structural then
+          leftAggr.joinStructural rightAggr
+        else
+          leftAggr.join rightAggr
+      let output := fromAggrCheckEnvTrees outputAggr
+      if output.subjectCount != item.subjectCount then
+        throw s!"aggregate join reconstructs {output.subjectCount} subjects, \
+          but the schedule records {item.subjectCount}"
+      let expectedShape := if item.structural then
+          Aggr.structuralShapeCode left.kind right.kind
+        else
+          Aggr.shapeCode (left.kind, some right.kind)
+      if item.kind != .aggr || item.shape? != some expectedShape then
+        throw s!"aggregate join {leftIdx},{rightIdx} has inconsistent kind/shape"
+      let outerClaim := aggregateOuterClaim allowed aggrIdx output.claim
+      specs := specs.push {
+        kind := .aggr
+        statement := output
+        subjectCount := item.subjectCount
+        outerClaim
+        cacheKey := aggregateCacheKey aggrVk recursionParameters outerClaim
+      }
+  pure specs
+
+private def addrOfHex (label value : String) : Except String Address :=
+  match Address.fromString value with
+  | some address => .ok address
+  | none => .error
+    s!"{label}: expected a 64-character address, got {value.length} characters"
+
+private def prepareOwnedShard (env : Ixon.Env) (owned : Array Address) :
+    Except String PreparedShard := do
+  let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned
+  let statement ← MultiStark.CheckEnvTrees.ofClaim claim trees
+  pure { claim, statement }
+
+/-- Reconstruct every shard statement after partitioning environment ownership
+in one pass. Calling `ownedConstsForBlocks` once per shard rescans the complete
+environment for every leaf, which made Mathlib aggregate startup take more
+than twenty minutes before the proof store was touched. -/
+def prepareShards (env : Ixon.Env) (shards : Array (Array Address))
+    (shardIds : Array Nat := #[]) : Except String (Array PreparedShard) := do
+  let ownedAll := Ix.Cli.CheckCmd.ownedConstsPer env shards
+  if ownedAll.size != shards.size then
+    throw s!"internal: prepared ownership for {ownedAll.size} shards, expected {shards.size}"
+  let mut prepared : Array PreparedShard := #[]
+  for (owned, shard) in ownedAll.mapIdx fun shard owned => (owned, shard) do
+    let originalShard := (shardIds[shard]?).getD shard
+    let item ← match prepareOwnedShard env owned with
+      | .error e => throw s!"prepare shard {originalShard}: {e}"
+      | .ok item => pure item
+    prepared := prepared.push item
+  pure prepared
+
+private def compileToplevel (label : String)
+    (source : Except Aiur.Global Aiur.Source.Toplevel) :
+    IO (Except String Aiur.CompiledToplevel) := do
+  match source with
+  | .error e => return Except.error s!"{label} toplevel merge failed: {e}"
+  | .ok top => match top.compile with
+    | .error e => return Except.error s!"{label} compilation failed: {e}"
+    | .ok compiled => return Except.ok compiled
+
+private structure AggregateBackend where
+  compiled : Aiur.CompiledToplevel
+  system : Aiur.AiurSystem
+  vk : ByteArray
+
+/-- Compile a Lean-authored Aiur program, then perform the Rust-side system
+construction and verifying-key serialization in the same worker. Keeping this
+pipeline together lets the independent IxVM and recursion backends build in
+parallel instead of serializing their Rust setup on the controller thread. -/
+private def buildAggregateBackend (label : String)
+    (source : Unit → Except Aiur.Global Aiur.Source.Toplevel)
+    (commitment : Aiur.CommitmentParameters) (fri : Aiur.FriParameters) :
+    IO (Except String AggregateBackend) := do
+  let source ← IO.lazyPure source
+  let compiled ← match ← compileToplevel label source with
+    | .error e => return .error e
+    | .ok compiled => pure compiled
+  let system := Aiur.AiurSystem.build compiled.bytecode commitment fri
+  let vk := system.vkBytes
+  return .ok { compiled, system, vk }
+
+private structure LoadedShardProof where
+  address : Address
+  wrapper : Ixon.Proof
+
+private def loadShardProofs (proofHexes : List String) :
+    IO (Except String (Array LoadedShardProof)) := do
+  let mut loaded : Array LoadedShardProof := #[]
+  for proofHex in proofHexes do
+    let proofAddress ← match addrOfHex "shard proof" proofHex with
+      | .error e => return .error e
+      | .ok address => pure address
+    let wrapper ← match Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddress)) with
+      | .error e =>
+        return .error s!"decode shard proof {proofAddress}: {e}"
+      | .ok wrapper => pure wrapper
+    loaded := loaded.push { address := proofAddress, wrapper }
+  return .ok loaded
+
+private def timed {α : Type} (action : IO α) : IO (α × Nat) := do
+  let started ← IO.monoMsNow
+  let result ← action
+  pure (result, (← IO.monoMsNow) - started)
+
+/-- Execute a post-order aggregate plan as a dependency-driven DAG. The
+controller is the sole owner of completion and reservation state: it admits a
+heaviest-first batch, starts one dedicated task per slot, then releases child
+dependencies as results arrive. `runSlot` receives an immutable snapshot in
+which every declared child is complete.
+
+On the first failure no further work is admitted, but already-running tasks
+are drained before returning. This prevents orphan proof tasks and permits
+successful independent slots to finish publishing cache entries safely. -/
+def runAggregateDag (plan : Array ScheduledFold) (weights : Array Nat)
+    (jobs budgetBytes : Nat)
+    (runSlot : Nat → Array (Option α) → IO (Except String α))
+    (trace : Bool := false) : IO (Except String (Array α)) := do
+  match aggregateScheduleInputsValid plan weights with
+  | .error e => return .error e
+  | .ok () => pure ()
+  if budgetBytes == 0 then
+    return .error "aggregate scheduler RAM budget must be positive"
+
+  let resultChan ← Std.CloseableChannel.Sync.new
+    (α := Nat × Nat × Except String α)
+  let mut tasks : Array (Task (Except IO.Error Unit)) := #[]
+  let mut slots : Array (Option α) := Array.replicate plan.size none
+  let mut completed := Array.replicate plan.size false
+  let mut inFlight := Array.replicate plan.size false
+  let mut completedCount := 0
+  let mut active := 0
+  let mut reservedBytes := 0
+  let mut failures : Array (Nat × String) := #[]
+  let maxJobs := if jobs == 0 then max 1 plan.size else max 1 jobs
+
+  while completedCount < plan.size do
+    if failures.isEmpty then
+      let admitted := admitAggregateReady plan weights completed inFlight
+        reservedBytes budgetBytes jobs
+      for slotIdx in admitted do
+        let weight := weights[slotIdx]!
+        inFlight := inFlight.set! slotIdx true
+        active := active + 1
+        reservedBytes := reservedBytes + weight
+        if trace then
+          let overBudget := if weight > budgetBytes then "; over-budget slot runs alone" else ""
+          IO.println s!"[aggregate] slot {slotIdx}: admitted {formatAggregateGiB weight} GiB; \
+            reserved {formatAggregateGiB reservedBytes}/{formatAggregateGiB budgetBytes} GiB; \
+            active {active}/{maxJobs}{overBudget}"
+        let snapshot := slots
+        let task ← IO.asTask (prio := .dedicated) do
+          let result ← try runSlot slotIdx snapshot catch e =>
+            pure (.error s!"uncaught IO error: {e}")
+          discard <| resultChan.send (slotIdx, weight, result)
+        tasks := tasks.push task
+
+    if active == 0 then
+      if failures.isEmpty then
+        failures := failures.push
+          (plan.size, "aggregate scheduler deadlocked with unfinished slots")
+      break
+
+    match ← resultChan.recv with
+    | none =>
+      failures := failures.push
+        (plan.size, "aggregate scheduler result channel closed unexpectedly")
+      break
+    | some (slotIdx, weight, result) =>
+      if !(inFlight[slotIdx]?).getD false then
+        failures := failures.push
+          (slotIdx, "aggregate scheduler received a duplicate or unknown result")
+      else
+        inFlight := inFlight.set! slotIdx false
+        active := active - 1
+        reservedBytes := reservedBytes - weight
+        match result with
+        | .error e => failures := failures.push (slotIdx, e)
+        | .ok value =>
+          slots := slots.set! slotIdx (some value)
+          completed := completed.set! slotIdx true
+          completedCount := completedCount + 1
+
+  -- A failure stops admission but never abandons tasks already inside an FFI
+  -- prove. Drain their channel results before closing and joining handles.
+  while active > 0 do
+    match ← resultChan.recv with
+    | none =>
+      failures := failures.push
+        (plan.size, "aggregate scheduler result channel closed while draining")
+      active := 0
+    | some (slotIdx, weight, result) =>
+      if (inFlight[slotIdx]?).getD false then
+        inFlight := inFlight.set! slotIdx false
+        active := active - 1
+        reservedBytes := reservedBytes - weight
+      match result with
+      | .error e => failures := failures.push (slotIdx, e)
+      | .ok value =>
+        slots := slots.set! slotIdx (some value)
+        if !(completed[slotIdx]?).getD false then
+          completed := completed.set! slotIdx true
+          completedCount := completedCount + 1
+  discard <| resultChan.close
+  for task in tasks do
+    match task.get with
+    | .ok () => pure ()
+    | .error e =>
+      failures := failures.push (plan.size,
+        s!"aggregate scheduler task failed: {e}")
+
+  if !failures.isEmpty then
+    let sortedFailures := failures.qsort fun left right => left.1 < right.1
+    let (slotIdx, e) := sortedFailures[0]!
+    return .error (if slotIdx < plan.size then s!"slot {slotIdx}: {e}" else e)
+
+  let mut result : Array α := #[]
+  for slotIdx in [:plan.size] do
+    let some value := (slots[slotIdx]?).join
+      | return .error s!"aggregate scheduler completed without slot {slotIdx}"
+    result := result.push value
+  pure (.ok result)
+
+def loadCachedAggregateProofWith
+    (readStore : Address → IO ByteArray) (dir : System.FilePath) (slotIdx : Nat)
+    (spec : AggregateSlotSpec) (recursionSystem : Aiur.AiurSystem) :
+    IO (Option CachedAggregateProof) := do
+  match ← readAggregateCacheAddress dir spec.cacheKey with
+  | .miss => return none
+  | .invalid reason =>
+    IO.println s!"[aggregate] slot {slotIdx}: cache miss ({reason})"
+    return none
+  | .hit address =>
+    try
+      let bytes ← readStore address
+      if Address.blake3 bytes != address then
+        IO.println s!"[aggregate] slot {slotIdx}: cache miss \
+          (store object {address} has a different content digest)"
+        return none
+      let wrapper ← match Ixon.Proof.de bytes with
+        | .ok wrapper => pure wrapper
+        | .error e =>
+          IO.println s!"[aggregate] slot {slotIdx}: cache miss \
+            (wrapper {address} does not decode: {e})"
+          return none
+      match validateAggregateCacheWrapper recursionSystem spec.statement.claim
+          spec.outerClaim wrapper with
+      | .ok proof =>
+        IO.println s!"[aggregate] slot {slotIdx}: cache hit {address}"
+        return some { proof, address }
+      | .error e =>
+        IO.println s!"[aggregate] slot {slotIdx}: cache miss \
+          (wrapper {address} rejected: {e})"
+        return none
+    catch e =>
+      IO.println s!"[aggregate] slot {slotIdx}: cache miss \
+        (cannot load wrapper {address}: {e})"
+      return none
+
+private def loadCachedAggregateProof (dir : System.FilePath) (slotIdx : Nat)
+    (spec : AggregateSlotSpec) (recursionSystem : Aiur.AiurSystem) :
+    IO (Option CachedAggregateProof) :=
+  loadCachedAggregateProofWith (fun address => StoreIO.toIO (Store.read address))
+    dir slotIdx spec recursionSystem
+
+private def persistAggregateCacheProof (dir : System.FilePath) (slotIdx : Nat)
+    (spec : AggregateSlotSpec) (proof : Aiur.Proof) : IO (Option Address) := do
+  try
+    let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser spec.statement.claim))
+    let wrapper : Ixon.Proof := { claim := spec.statement.claim, proof := proof.toBytes }
+    let address ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper))
+    writeAggregateCacheAddress dir spec.cacheKey address
+    IO.println s!"[aggregate] slot {slotIdx}: cached proof {address}"
+    return some address
+  catch e =>
+    IO.eprintln s!"[aggregate] slot {slotIdx}: warning: could not persist cache entry: {e}"
+    return none
+
+private def printPlan (plan : Array ScheduledFold) (shardIds : Array Nat)
+    (structuralAbove : Nat) : IO Unit := do
+  let leaves := plan.countP fun item => match item.op with
+    | .leaf _ => true
+    | .join _ _ => false
+  let wraps := plan.countP fun item => match item.op with
+    | .leaf _ => item.kind == .aggr
+    | .join _ _ => false
+  let structural := plan.countP (·.structural)
+  let directLeaves := leaves - wraps
+  let leafPolicy := if directLeaves == 0 then s!"{wraps} wraps"
+    else s!"{directLeaves} direct IxVM leaves"
+  IO.println s!"[aggregate] plan: {leafPolicy} + {plan.size - leaves} binary joins \
+    ({structural} structural; threshold > {structuralAbove} subject leaves)"
+  for (item, slot) in plan.mapIdx fun slot item => (item, slot) do
+    match item.op with
+    | .leaf shard =>
+      let originalShard := (shardIds[shard]?).getD shard
+      let mode := if item.kind == .ixvm then "raw shard" else "wrap shard"
+      IO.println s!"  slot {slot}: {mode} {originalShard} ({item.subjectCount} subjects)"
+    | .join left right =>
+      let mode := if item.structural then "structural" else "flat"
+      IO.println s!"  slot {slot}: {mode} shape {item.shape?.getD 255} \
+        slots {left}, {right} ({item.subjectCount} subjects)"
+
+private structure AggregateProveContext where
+  plan : Array ScheduledFold
+  specs : Array AggregateSlotSpec
+  prepared : Array PreparedShard
+  proofsByShard : Std.HashMap Nat Ixon.Proof
+  shardIds : Array Nat
+  ixvmSystem : Aiur.AiurSystem
+  aggrSystem : Aiur.AiurSystem
+  ixvmVk : ByteArray
+  aggrVk : ByteArray
+  allowed : ByteArray
+  verifyIdx : Aiur.Bytecode.FunIdx
+  aggrIdx : Aiur.Bytecode.FunIdx
+  cacheDir? : Option System.FilePath
+
+/-- Prove or resume one slot whose dependencies have already completed. The
+scheduler catches IO exceptions around this function; protocol and validation
+failures stay explicit so the lowest failed slot can be reported
+deterministically after all admitted tasks drain. -/
+private def proveAggregateSlot (ctx : AggregateProveContext) (slotIdx : Nat)
+    (slots : Array (Option AggregateSlot)) : IO (Except String AggregateSlot) := do
+  let some item := ctx.plan[slotIdx]?
+    | return .error "missing scheduled fold item"
+  let some spec := ctx.specs[slotIdx]?
+    | return .error "missing prepared aggregate slot"
+  match item.op with
+  | .leaf shard =>
+    let originalShard := (ctx.shardIds[shard]?).getD shard
+    let some wrapper := ctx.proofsByShard.get? shard
+      | return .error s!"no proof for shard {originalShard}"
+    let some preparedShard := ctx.prepared[shard]?
+      | return .error s!"no statement for shard {originalShard}"
+    let claimBytes := Ix.Claim.ser preparedShard.claim
+    let verifyInput := IxVM.ClaimHarness.packedDigestKey
+      (Address.blake3 claimBytes)
+    let innerClaim := Aiur.buildClaim ctx.verifyIdx verifyInput #[]
+    let innerProof ← match Aiur.Proof.ofBytesChecked wrapper.proof with
+      | .error e =>
+        return Except.error s!"shard {originalShard} proof does not decode: {e}"
+      | .ok proof => pure proof
+    match ctx.ixvmSystem.verify innerClaim innerProof with
+    | .error e =>
+      return Except.error s!"shard {originalShard} proof fails native verification: {e}"
+    | .ok () => pure ()
+    let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim]
+    match spec.kind with
+    | .ixvm =>
+      if spec.outerClaim != innerClaim then
+        return .error "direct shard slot has an unexpected outer claim"
+      return .ok {
+        kind := .ixvm
+        statement := spec.statement
+        subjectCount := spec.subjectCount
+        outerClaim := innerClaim
+        proof := innerProof
+        proofAddress? := none
+        claimsBytes := innerClaimsBytes
+      }
+    | .aggr =>
+      let cached? ← match ctx.cacheDir? with
+        | none => pure none
+        | some dir => loadCachedAggregateProof dir slotIdx spec ctx.aggrSystem
+      let (proof, proofAddress?) ← match cached? with
+        | some cached => pure (cached.proof, some cached.address)
+        | none =>
+          let innerProofAdvice ← match ctx.ixvmSystem.proofToAdviceBytes
+              innerClaim innerProof with
+            | .error e =>
+              return .error s!"shard {originalShard} proof advice encoding failed: {e}"
+            | .ok bytes => pure bytes
+          let shape := item.shape?.getD (Aggr.shapeCode (.ixvm, none))
+          let pubInput := Aggr.pubInput ctx.allowed claimBytes
+          IO.println s!"[aggregate] wrapping shard {originalShard} into slot {slotIdx}"
+          (← IO.getStdout).flush
+          let result := ctx.aggrSystem.proveIxAggr ctx.aggrIdx pubInput shape
+            innerProofAdvice ByteArray.empty ctx.ixvmVk ctx.aggrVk
+            innerClaimsBytes ByteArray.empty claimBytes ctx.allowed
+            (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[])
+          let (outerClaim, proof) ← match result with
+            | .error e => return .error s!"wrap proving failed: {e}"
+            | .ok result => pure result
+          if outerClaim != spec.outerClaim then
+            return .error "wrap produced an unexpected outer claim"
+          let proofAddress? ← match ctx.cacheDir? with
+            | none => pure none
+            | some dir => persistAggregateCacheProof dir slotIdx spec proof
+          pure (proof, proofAddress?)
+      return .ok {
+        kind := .aggr
+        statement := spec.statement
+        subjectCount := spec.subjectCount
+        outerClaim := spec.outerClaim
+        proof
+        proofAddress?
+        claimsBytes := MultiStark.serializeClaims #[spec.outerClaim]
+      }
+  | .join leftIdx rightIdx =>
+    let some left := (slots[leftIdx]?).join
+      | return .error s!"missing completed left slot {leftIdx}"
+    let some right := (slots[rightIdx]?).join
+      | return .error s!"missing completed right slot {rightIdx}"
+    let output := spec.statement
+    let outputClaimBytes := Ix.Claim.ser output.claim
+    let cached? ← match ctx.cacheDir? with
+      | none => pure none
+      | some dir => loadCachedAggregateProof dir slotIdx spec ctx.aggrSystem
+    let (proof, proofAddress?) ← match cached? with
+      | some cached => pure (cached.proof, some cached.address)
+      | none =>
+        let pubInput := Aggr.pubInput ctx.allowed outputClaimBytes
+        let leftClaimsBytes := left.claimsBytes
+        let rightClaimsBytes := right.claimsBytes
+        let leftStatement := toAggrCheckEnvTrees left.statement
+        let rightStatement := toAggrCheckEnvTrees right.statement
+        let outputStatement := toAggrCheckEnvTrees output
+        let preimagesBlob := Aggr.preimagesBlob
+          #[Ix.Claim.ser left.statement.claim, Ix.Claim.ser right.statement.claim]
+        let trees := if item.structural then
+            Aggr.CheckEnvTrees.structuralAdviceTrees
+              leftStatement rightStatement outputStatement
+          else
+            Aggr.CheckEnvTrees.adviceTrees
+              leftStatement rightStatement outputStatement
+        let treesBlob := Aggr.treesBlob trees
+        let pathsBlob := if item.structural then
+            Aggr.pathsBlob
+              (Aggr.CheckEnvTrees.structuralPathAdvice
+                leftStatement rightStatement outputStatement)
+          else
+            Aggr.pathsBlob #[]
+        let mode := if item.structural then "structural" else "flat"
+        let leftSystem := match left.kind with
+          | .ixvm => ctx.ixvmSystem
+          | .aggr => ctx.aggrSystem
+        let rightSystem := match right.kind with
+          | .ixvm => ctx.ixvmSystem
+          | .aggr => ctx.aggrSystem
+        let leftProofAdvice ← match leftSystem.proofToAdviceBytes
+            left.outerClaim left.proof with
+          | .error e => return .error s!"left child proof advice encoding failed: {e}"
+          | .ok bytes => pure bytes
+        let rightProofAdvice ← match rightSystem.proofToAdviceBytes
+            right.outerClaim right.proof with
+          | .error e => return .error s!"right child proof advice encoding failed: {e}"
+          | .ok bytes => pure bytes
+        IO.println s!"[aggregate] {mode}-joining slots {leftIdx}, {rightIdx} into {slotIdx}"
+        (← IO.getStdout).flush
+        let some shape := item.shape?
+          | return .error "aggregate pair is missing its ix_aggr shape"
+        let result := ctx.aggrSystem.proveIxAggr ctx.aggrIdx pubInput shape
+          leftProofAdvice rightProofAdvice ctx.ixvmVk ctx.aggrVk
+          leftClaimsBytes rightClaimsBytes outputClaimBytes ctx.allowed
+          preimagesBlob treesBlob pathsBlob
+        let (outerClaim, proof) ← match result with
+          | .error e => return .error e
+          | .ok result => pure result
+        if outerClaim != spec.outerClaim then
+          return .error "join produced an unexpected outer claim"
+        let proofAddress? ← match ctx.cacheDir? with
+          | none => pure none
+          | some dir => persistAggregateCacheProof dir slotIdx spec proof
+        pure (proof, proofAddress?)
+    return .ok {
+      kind := .aggr
+      statement := output
+      subjectCount := spec.subjectCount
+      outerClaim := spec.outerClaim
+      proof
+      proofAddress?
+      claimsBytes := MultiStark.serializeClaims #[spec.outerClaim]
+    }
+
+/-- Production Stage 2 entrypoint. The Lean-authored circuit sources still
+compile here, in parallel with mmap-loading the environment. Once both Aiur
+systems exist, one FFI call transfers the complete data-dependent pipeline to
+Rust; no Lean statement tree or scheduler task survives on this path. -/
+private def runAggregateCmdNativeWith
+    (recursionParameters : MultiStark.RecursionParameters)
+    (p : Cli.Parsed) : IO UInt32 := do
+  let some ixePath := (p.flag? "ixe").map (·.as! String) | do
+    p.printError "error: aggregate requires --ixe <env.ixe>"
+    return 1
+  let some manifestPath := (p.flag? "ixes").map (·.as! String) | do
+    p.printError "error: aggregate requires --ixes <manifest.ixes>"
+    return 1
+  let maxRamGb? := (p.flag? "max-ram").map (·.as! Nat)
+  if maxRamGb? == some 0 then
+    IO.eprintln "error: --max-ram must be positive"
+    return 1
+  let ramBudgetBytes ← match maxRamGb? with
+    | some gib => pure (gib * aggregateGiB)
+    | none => defaultAggregateRamBudgetBytes
+  let jobs := ((p.flag? "jobs").map (·.as! Nat)).getD 0
+  let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD
+    defaultStructuralAbove
+  let proofHexes := String.intercalate "\n"
+    (p.variableArgsAs! String).toList
+
+  let setupStarted ← IO.monoMsNow
+  let envTask ← IO.asTask (prio := .dedicated) do
+    timed (IO.lazyPure fun _ => Aiur.EnvHandle.fromIxe ixePath)
+  let ixvmBackendTask ← IO.asTask (prio := .dedicated) do
+    timed (buildAggregateBackend "IxVM" (fun _ => IxVM.ixVM)
+      Aiur.defaultCommitmentParameters Aiur.defaultFriParameters)
+  let aggrBackendTask ← IO.asTask (prio := .dedicated) do
+    timed (buildAggregateBackend "ixAggr recursion" (fun _ => Aggr.ixAggr)
+      recursionParameters.commitment recursionParameters.fri)
+
+  -- Join every setup branch before selecting an error, so a failed branch
+  -- cannot orphan compilation work in the process.
+  let (envResult, envMs) ← IO.ofExcept envTask.get
+  let (ixvmResult, ixvmMs) ← IO.ofExcept ixvmBackendTask.get
+  let (aggrResult, aggrMs) ← IO.ofExcept aggrBackendTask.get
+  let setupMs := (← IO.monoMsNow) - setupStarted
+  IO.println s!"[aggregate] parallel host setup: {setupMs}ms \
+    (environment {envMs}ms, IxVM backend {ixvmMs}ms, ixAggr backend {aggrMs}ms)"
+  (← IO.getStdout).flush
+
+  let envHandle ← match envResult with
+    | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1
+    | .ok handle => pure handle
+  let ixvmBackend ← match ixvmResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok backend => pure backend
+  let aggrBackend ← match aggrResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok backend => pure backend
+  let verifyIdx := ixvmBackend.compiled.getFuncIdx `verify_claim |>.get!
+  let aggrIdx := aggrBackend.compiled.getFuncIdx `ix_aggr |>.get!
+  let nativeResult ← IO.lazyPure fun _ =>
+    ixvmBackend.system.aggregateStage2 aggrBackend.system envHandle
+      manifestPath proofHexes verifyIdx aggrIdx jobs ramBudgetBytes
+      structuralAbove (p.hasFlag "direct-joins")
+      (p.hasFlag "plan-only")
+      recursionParameters.cacheFriBytes !(p.hasFlag "no-cache")
+  match nativeResult with
+  | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1
+  | .ok _ => return 0
+
+/-- Aggregate with an explicit recursion-proof configuration. The CLI wrapper
+below supplies `defaultRecursionParameters`; keeping this seam explicit lets a
+future policy or cache layer select a recursion configuration without changing
+the canonical IxVM proof parameters. -/
+private def runAggregateCmdLeanReferenceWith
+    (recursionParameters : MultiStark.RecursionParameters)
+    (p : Cli.Parsed) : IO UInt32 := do
+  let some ixePath := (p.flag? "ixe").map (·.as! String) | do
+    p.printError "error: aggregate requires --ixe <env.ixe>"
+    return 1
+  let some manifestPath := (p.flag? "ixes").map (·.as! String) | do
+    p.printError "error: aggregate requires --ixes <manifest.ixes>"
+    return 1
+
+  let startupStarted ← IO.monoMsNow
+
+  let rawView ← match Ix.Cli.CheckCmd.parseIxesManifest
+      (← IO.FS.readBinFile manifestPath) with
+    | .error e => IO.eprintln s!"manifest parse failed: {e}"; return 1
+    | .ok view => pure view
+  let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with
+    | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1
+    | .ok env => pure env
+  if !(← Ix.Cli.CheckCmd.shardsCover env rawView.shards) then return 1
+  let (view, shardCounts) ← match rawView.pruneEmpty env with
+    | .error e => IO.eprintln e; return 1
+    | .ok pruned => pure pruned
+  let prunedCount := rawView.shards.size - view.shards.size
+  if prunedCount != 0 then
+    IO.println s!"[aggregate] pruned {prunedCount} zero-constant manifest shard(s)"
+
+  let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD
+    defaultStructuralAbove
+  let directJoins := p.hasFlag "direct-joins"
+  let plan ← match schedulePlan view.aggregationTree.foldPlan shardCounts
+      structuralAbove directJoins with
+    | .error e => IO.eprintln e; return 1
+    | .ok plan => pure plan
+  printPlan plan view.shardIds structuralAbove
+  let jobs := ((p.flag? "jobs").map (·.as! Nat)).getD 0
+  let maxRamGb? := (p.flag? "max-ram").map (·.as! Nat)
+  if maxRamGb? == some 0 then
+    IO.eprintln "error: --max-ram must be positive"
+    return 1
+  let ramBudgetBytes ← match maxRamGb? with
+    | some gib => pure (gib * aggregateGiB)
+    | none => defaultAggregateRamBudgetBytes
+  let slotWeights := aggregateSlotRamWeights plan
+  let jobsLabel := if jobs == 0 then "all ready slots" else toString jobs
+  let budgetSource := if maxRamGb?.isSome then "--max-ram" else "92% MemTotal"
+  IO.println s!"[aggregate] scheduler: jobs={jobsLabel}, RAM budget \
+    {formatAggregateGiB ramBudgetBytes} GiB ({budgetSource}); \
+    wrap/self reserve {formatAggregateGiB aggregateWrapRamBytes} GiB, \
+    direct {formatAggregateGiB aggregateDirectJoinRamBytes} GiB, mixed \
+    {formatAggregateGiB aggregateMixedJoinRamBytes} GiB, flat +1 MiB/subject"
+  if p.hasFlag "plan-only" then return 0
+
+  let proofHexes := (p.variableArgsAs! String).toList
+  if proofHexes.length != view.shards.size then
+    IO.eprintln s!"aggregate requires exactly {view.shards.size} shard proofs; got {proofHexes.length}"
+    return 1
+
+  -- Statement preparation, proof loading, and the two independent backend
+  -- setup pipelines have no data dependencies. Run all four branches together,
+  -- then join every task before selecting a deterministic error to report.
+  let parallelStarted ← IO.monoMsNow
+  let prepareTask ← IO.asTask (prio := .dedicated) do
+    timed (IO.lazyPure fun _ => prepareShards env view.shards view.shardIds)
+  let proofsTask ← IO.asTask (prio := .dedicated) do
+    timed (loadShardProofs proofHexes)
+  let ixvmBackendTask ← IO.asTask (prio := .dedicated) do
+    timed (buildAggregateBackend "IxVM" (fun _ => IxVM.ixVM)
+      Aiur.defaultCommitmentParameters Aiur.defaultFriParameters)
+  let aggrBackendTask ← IO.asTask (prio := .dedicated) do
+    timed (buildAggregateBackend "ixAggr recursion" (fun _ => Aggr.ixAggr)
+      recursionParameters.commitment recursionParameters.fri)
+
+  let prepareOutcome := prepareTask.get
+  let proofsOutcome := proofsTask.get
+  let ixvmBackendOutcome := ixvmBackendTask.get
+  let aggrBackendOutcome := aggrBackendTask.get
+  let (prepareResult, prepareMs) ← IO.ofExcept prepareOutcome
+  let (proofsResult, proofsMs) ← IO.ofExcept proofsOutcome
+  let (ixvmBackendResult, ixvmBackendMs) ← IO.ofExcept ixvmBackendOutcome
+  let (aggrBackendResult, aggrBackendMs) ← IO.ofExcept aggrBackendOutcome
+  let parallelMs := (← IO.monoMsNow) - parallelStarted
+  let startupMs := (← IO.monoMsNow) - startupStarted
+  IO.println s!"[aggregate] startup: parse/plan {parallelStarted - startupStarted}ms; \
+    parallel wall {parallelMs}ms (prepare {prepareMs}ms, proofs {proofsMs}ms, \
+    IxVM backend {ixvmBackendMs}ms, ixAggr backend {aggrBackendMs}ms); \
+    total {startupMs}ms"
+  (← IO.getStdout).flush
+
+  let prepared ← match prepareResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok prepared => pure prepared
+  let loadedProofs ← match proofsResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok loaded => pure loaded
+  let ixvmBackend ← match ixvmBackendResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok backend => pure backend
+  let aggrBackend ← match aggrBackendResult with
+    | .error e => IO.eprintln e; return 1
+    | .ok backend => pure backend
+
+  -- Proof arguments may be in any order. Match them by their bundled claim and
+  -- reject duplicates/missing shards before starting an expensive wrap.
+  let mut digestToShard : Std.HashMap Address Nat := {}
+  for (item, shard) in prepared.mapIdx fun shard item => (item, shard) do
+    let originalShard := (view.shardIds[shard]?).getD shard
+    let digest := Address.blake3 (Ix.Claim.ser item.claim)
+    if digestToShard.contains digest then
+      IO.eprintln s!"duplicate reconstructed shard claim digest {digest} \
+        (manifest shard {originalShard})"
+      return 1
+    digestToShard := digestToShard.insert digest shard
+
+  let mut proofsByShard : Std.HashMap Nat Ixon.Proof := {}
+  for loaded in loadedProofs do
+    let proofAddress := loaded.address
+    let wrapper := loaded.wrapper
+    let digest := Address.blake3 (Ix.Claim.ser wrapper.claim)
+    let some shard := digestToShard.get? digest | do
+      IO.eprintln s!"proof {proofAddress} claim {digest} matches no manifest shard"
+      return 1
+    let some expected := prepared[shard]? | do
+      IO.eprintln s!"internal: missing prepared shard {shard}"
+      return 1
+    let originalShard := (view.shardIds[shard]?).getD shard
+    if wrapper.claim != expected.claim then
+      IO.eprintln s!"proof {proofAddress} hit a claim-digest collision for shard {originalShard}"
+      return 1
+    if proofsByShard.contains shard then
+      IO.eprintln s!"more than one proof supplied for shard {originalShard}"
+      return 1
+    proofsByShard := proofsByShard.insert shard wrapper
+  if proofsByShard.size != view.shards.size then
+    IO.eprintln "not every manifest shard has a supplied proof"
+    return 1
+
+  let verifyIdx := ixvmBackend.compiled.getFuncIdx `verify_claim |>.get!
+  let aggrIdx := aggrBackend.compiled.getFuncIdx `ix_aggr |>.get!
+  let ixvmSystem := ixvmBackend.system
+  let aggrSystem := aggrBackend.system
+  let ixvmVk := ixvmBackend.vk
+  let aggrVk := aggrBackend.vk
+  let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx
+  let specs ← match buildAggrSlotSpecs plan prepared aggrVk allowed
+      verifyIdx aggrIdx recursionParameters with
+    | .error e => IO.eprintln s!"prepare aggregate slots: {e}"; return 1
+    | .ok specs => pure specs
+  let cacheDir? ← if p.hasFlag "no-cache" then
+      IO.println "[aggregate] cache disabled (--no-cache)"
+      pure none
+    else
+      pure (some (← aggregateCacheDir))
+
+  let proveContext : AggregateProveContext := {
+    plan, specs, prepared, proofsByShard, shardIds := view.shardIds
+    ixvmSystem, aggrSystem, ixvmVk, aggrVk, allowed
+    verifyIdx, aggrIdx, cacheDir?
+  }
+  let slots ← match ← runAggregateDag plan slotWeights jobs ramBudgetBytes
+      (proveAggregateSlot proveContext) true with
+    | .error e => IO.eprintln s!"aggregate failed: {e}"; return 1
+    | .ok slots => pure slots
+
+  let some root := slots.back? | do
+    IO.eprintln "aggregate plan produced no root slot"
+    return 1
+  if root.kind != .aggr then
+    IO.eprintln "aggregate plan produced a raw IxVM root instead of an ix_aggr proof"
+    return 1
+  let some envTree := IxVM.ClaimHarness.envCanonicalTree env | do
+    IO.eprintln "cannot aggregate an empty environment"
+    return 1
+  let some canonicalRoot := Ix.AssumptionTree.canonical root.statement.subjects.leaves | do
+    IO.eprintln "aggregate root subject tree has no real leaves"
+    return 1
+  if canonicalRoot.root != envTree.root then
+    IO.eprintln s!"aggregate root subjects canonicalize to {canonicalRoot.root}, not env root {envTree.root}"
+    return 1
+  if root.statement.assumptions.isSome then
+    IO.eprintln s!"aggregate root retains undischarged assumptions {root.statement.assumptions.map (·.root)}"
+    return 1
+  match aggrSystem.verify root.outerClaim root.proof with
+  | .error e => IO.eprintln s!"aggregate root proof failed native verification: {e}"; return 1
+  | .ok () => pure ()
+
+  let proofAddress ← match root.proofAddress? with
+    | some address => pure address
+    | none =>
+      let claim := root.statement.claim
+      let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim))
+      let wrapper : Ixon.Proof := { claim, proof := root.proof.toBytes }
+      StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper))
+  IO.println s!"[aggregate] root proof: {proofAddress}"
+  return 0
+
+/-- Aggregate through the native Stage 2 controller. The retained Lean driver
+above is a protocol reference and unit-test seam; it is not on the CLI path. -/
+def runAggregateCmdWith (recursionParameters : MultiStark.RecursionParameters)
+    (p : Cli.Parsed) : IO UInt32 :=
+  runAggregateCmdNativeWith recursionParameters p
+
+def runAggregateCmd (p : Cli.Parsed) : IO UInt32 :=
+  runAggregateCmdWith MultiStark.defaultRecursionParameters p
+
+end Ix.Cli.AggregateCmd
+
+open Ix.Cli.AggregateCmd in
+def aggregateCmd : Cli.Cmd := `[Cli|
+  aggregate VIA runAggregateCmd;
+  "Wrap shard proofs and fold multi-shard manifests into one recursive aggregate"
+
+  FLAGS:
+    "ixe" : String;  "Path to the serialized environment whose shards were proven."
+    "ixes" : String; "Path to the shard manifest; its bisection tree determines join order."
+    "plan-only";     "Validate coverage and print the wrap/join slot plan without loading or proving shard proofs."
+    "no-cache";      "Bypass aggregate cache reads and intermediate cache writes; the root wrapper is still persisted."
+    "jobs" : Nat;    "Maximum aggregate slots proving concurrently (default 0: all ready slots, subject to the RAM gate)."
+    "max-ram" : Nat; "Aggregate in-flight RAM budget in GiB (default: 92% of MemTotal). An estimated-oversized slot runs alone."
+    "structural-above" : Nat; "Use structural joins when a node contains more than N subject leaves (default 4096; 0 means every join)."
+    "direct-joins";  "Keep IxVM leaves raw until their first pair instead of wrapping first (non-default; substantially higher RAM)."
+
+  ARGS:
+    ...proofs : String; "Persisted shard-proof wrapper addresses, in any order (exactly one per nonempty shard unless --plan-only)."
+]
+
+end
diff --git a/Ix/Cli/BenchCmd.lean b/Ix/Cli/BenchCmd.lean
index f43c9a932..a6949bc63 100644
--- a/Ix/Cli/BenchCmd.lean
+++ b/Ix/Cli/BenchCmd.lean
@@ -136,11 +136,13 @@ def workloadOf (testbed : String) : String :=
 /-- The stage qualifiers a pipeline measure may carry ahead of its base
     name — one per pipeline stage, named for what the stage proves
     (`ixvm-`: the IxVM typecheck; `fri-verifier-`: the in-circuit FRI
-    verifier over the previous proof; the KZG stages add their own
-    entries as they land) — plus `pipeline-` for the whole run. Stripped
+    verifier over the previous proof; `join-`: the optional pair-wide
+    aggregate join; the KZG stages add their own entries as they land) —
+    plus `pipeline-` for the whole run. Stripped
     wherever a measure is interpreted by its base name (formatting kind,
     units) or labelled under a heading that already says the stage. -/
-def stagePrefixes : List String := ["ixvm-", "fri-verifier-", "pipeline-"]
+def stagePrefixes : List String :=
+  ["ixvm-", "fri-verifier-", "join-", "pipeline-"]
 
 /-- The stage qualifier `metric` carries, if any. -/
 def stagePrefixOf (metric : String) : Option String :=
@@ -213,7 +215,9 @@ structure BackendSpec where
 
 def backendSpecs : List BackendSpec := [
   -- aiur: the proof-pipeline benchmark (bench-typecheck --recursive) —
-  -- every stage of the pipeline, per constant, plus the total. The ixvm
+  -- every stage of the pipeline, per constant, plus the total. The optional
+  -- `bench-typecheck --join` W0 diagnostic contributes a separate pair row;
+  -- it is not part of the scheduled one-constant CI invocation. The ixvm
   -- stage proves the constant's IxVM typecheck; the fri-verifier stage
   -- executes the in-circuit multi-stark verifier over that fresh proof
   -- and proves THAT execution; the KZG stages will join as stages 3/4
@@ -245,6 +249,9 @@ def backendSpecs : List BackendSpec := [
           "fri-verifier-throughput", "fri-verifier-peak-rss",
           "fri-verifier-proof-size", "fri-verifier-verify-time",
           "fri-verifier-fft-cost"]),
+       ("Aggregate flat join",
+         ["join-execute-time", "join-prove-time", "join-peak-rss",
+          "join-proof-size", "join-verify-time", "join-fft-cost"]),
        ("Pipeline total",
          ["total-time", "pipeline-throughput", "pipeline-peak-rss"])])],
     metrics := [("execute", ["execute-time", "throughput", "peak-rss",
@@ -269,6 +276,12 @@ def backendSpecs : List BackendSpec := [
                    ("fri-verifier-prove-time", "0.10", "_"),
                    ("ixvm-peak-rss", "0.10", "_"),
                    ("fri-verifier-peak-rss", "0.10", "_"),
+                   ("join-execute-time", "0.10", "_"),
+                   ("join-prove-time", "0.10", "_"),
+                   ("join-peak-rss", "0.10", "_"),
+                   ("join-proof-size", "0.05", "_"),
+                   ("join-verify-time", "0.10", "_"),
+                   ("join-fft-cost", "0.25", "_"),
                    ("pipeline-peak-rss", "0.10", "_"),
                    ("ixvm-proof-size", "0.05", "_"),
                    ("fri-verifier-proof-size", "0.05", "_"),
@@ -276,16 +289,18 @@ def backendSpecs : List BackendSpec := [
                    ("fri-verifier-verify-time", "0.10", "_")] },
   -- aiur-sharded-env: whole-env Aiur execution — the sharded feeder pipeline
   -- end-to-end at env scale, one row per env. Shards the `.ixe` for the
-  -- runner's RAM (`ix shard --max-ram 100`: naive sizing → ~3.5 GB
-  -- execution RSS per shard on a 128 GB runner), then one gated
-  -- full-width rayon batch (`ix check --ixe --ixes`) over the whole
-  -- manifest — the byte-weighted RamGate, not a thread cap, bounds peak
-  -- RSS, so the same entry is correct on any runner class. ISLB only
-  -- for now (~10 min/run); add "FLT" / "Mathlib" to `envs` for the
-  -- env-scale tiers (~30-45 min each on the 32x runner) when their
-  -- per-push cost is warranted. `shards` is deterministic per
-  -- (env bytes, budget) and only drops on a real compression win →
-  -- upper-only pin.
+  -- runner's RAM (`ix shard --max-ram 100`: seed sizing), then one gated
+  -- full-width rayon batch with the split audit (`ix check --ram-budget
+  -- 100`): a seed the spread pushes over the budget is cut in place and
+  -- its parts re-measured, so the row describes the LEAF partition the
+  -- run validated. The byte-weighted RamGate, not a thread cap, bounds
+  -- peak RSS, so the same entry is correct on any runner class. The
+  -- measured window (`check-time`) is the wave-0 batch call; split
+  -- waves are audit extras outside it. ISLB only for now (~10 min/run);
+  -- add "FLT" / "Mathlib" to `envs` for the env-scale tiers when their
+  -- per-push cost is warranted. `shards` counts leaves — deterministic
+  -- per (env static block profile, budget), rising only when the seed under-counts →
+  -- upper-only pin, re-pin on a justified seed or split change.
   { name := "aiur-sharded-env", defaultMode := "execute", inputs := .perEnv,
     envs := some ["ISLB"],
     testbeds := [("execute", "aiur-sharded-env-check-x64-32x")],
@@ -418,6 +433,14 @@ def BackendSpec.envNames (b : BackendSpec) : List String :=
       b.scheduledModes.any fun m =>
         !(selectNames env b.name m).isEmpty
 
+/-- Stable pair rows produced by the opt-in aggregate W0 diagnostic. These are
+    registered for dashboard filtering even though the scheduled aiur cell
+    remains one process per constant and therefore does not produce them. Keep
+    the order synchronized with the documented `bench-typecheck --join`
+    invocation: pair-row identity is deliberately order-sensitive. -/
+def aiurJoinBenchmarkNames : Array String :=
+  #["Nat.add_comm + String.append"]
+
 /-- The benchmark row names this backend uploads — the bencher slugs the
     dashboard plots and compare table key on — from its `inputs`: env-keyed
     backends key one row per compiled env; the per-constant backends select
@@ -433,6 +456,8 @@ def BackendSpec.benchmarkNames (b : BackendSpec) (mode : String) :
     for env in b.envNames do
       if b.inputs == .perConstantWithEnv then ns := ns.push env
       ns := ns ++ (selectNames env b.name mode).map (·.name)
+    if b.name == "aiur" && mode == "prove" then
+      return ns ++ aiurJoinBenchmarkNames
     return ns
 
 /-- Default RAM watchdog ceiling (`--ceiling-gb` overrides): see
@@ -747,23 +772,29 @@ is not a benchmark run"
       if exit != 0 && exit != exitRejected then
         IO.eprintln s!"[bench] per-constant checks failed (exit {exit})"
   | "aiur-sharded-env" =>
-    -- Whole-env sharded Aiur execution: shard the env for the runner's
-    -- RAM (naive `--max-ram 100` sizing → ~3.5 GB execution RSS per
-    -- shard), then ONE gated full-width rayon batch over the manifest —
-    -- the RamGate bounds peak RSS, so no `--jobs` is passed. The check
-    -- writes the env-keyed row itself (`--json`): check-time,
-    -- throughput, peak-rss, constants, shards. The shard step is
-    -- deterministic setup, not part of the measured window.
+    -- Whole-env sharded Aiur execution: seed the env for the runner's RAM
+    -- from its static block-shape score (`--max-ram 100`), then ONE gated
+    -- full-width rayon batch over the manifest — the RamGate bounds peak
+    -- RSS, so no `--jobs` is passed. The check writes the env-keyed row
+    -- itself (`--json`): check-time, throughput, peak-rss, constants,
+    -- shards. The shard step is deterministic setup, not part of the
+    -- measured window.
     let ixe ← ensureIxe repo info ((p.flag? "ixe").map (·.as! String))
     let ix ← resolveBin repo "ix"
     let manifest := s!"{env}-exec.ixes"
+    -- One budget for both stages: the shard step seeds for it, and the
+    -- check's split audit (`--ram-budget`) cuts any seed the spread
+    -- pushes over it in place — the row's `shards` counts the LEAF
+    -- partition the run actually validated. 100 GiB = the 128 GB
+    -- runner class the testbed pins.
+    let budgetGib := "100"
     let exit ← runGuarded watchdog ceilingGb ix
-      #["shard", ixe, "--max-ram", "100", "--out", manifest]
+      #["shard", ixe, "--max-ram", budgetGib, "--out", manifest]
     if exit != 0 then
       IO.eprintln s!"[bench] ix shard failed (exit {exit})"
       return 1
     let exit ← runGuarded watchdog ceilingGb ix
-      #["check", "--ixe", ixe, "--ixes", manifest,
+      #["check", "--ixe", ixe, "--ixes", manifest, "--ram-budget", budgetGib,
         "--json", out, "--json-name", info.name]
     if exit != 0 && exit != exitRejected then
       IO.eprintln s!"[bench] whole-env aiur check failed (exit {exit})"
diff --git a/Ix/Cli/BenchPlots.lean b/Ix/Cli/BenchPlots.lean
index 2aa97bfff..b6e4447d8 100644
--- a/Ix/Cli/BenchPlots.lean
+++ b/Ix/Cli/BenchPlots.lean
@@ -70,6 +70,11 @@ def plotTitle (workload measure : String) : String :=
   | "aiur", "fri-verifier-peak-rss"    => "Aiur FRI Verifier Peak RAM Usage"
   | "aiur", "ixvm-proof-size"          => "Aiur IxVM Proof Size"
   | "aiur", "fri-verifier-proof-size"  => "Aiur FRI Verifier Proof Size"
+  | "aiur", "join-prove-time"          => "Aiur Aggregate Join Time"
+  | "aiur", "join-fft-cost"            => "Aiur Aggregate Join FFT Cost"
+  | "aiur", "join-verify-time"         => "Aiur Aggregate Join Verify Time"
+  | "aiur", "join-peak-rss"            => "Aiur Aggregate Join Peak RAM Usage"
+  | "aiur", "join-proof-size"          => "Aiur Aggregate Join Proof Size"
   | "zisk-check-execute", "execute-time" => "Zisk Execute Time"
   | "zisk-check-execute", "throughput"   => "Zisk Execute Throughput"
   | "zisk-check-execute", "peak-rss"     => "Zisk Execute Peak RAM Usage"
@@ -111,6 +116,7 @@ def plotSkips : List (String × String) :=
    ("ix-decompile", "file-size"), ("ix-decompile", "constants"),
    ("aiur", "ixvm-peak-rss"), ("aiur", "ixvm-verify-time"),
    ("aiur", "ixvm-execute-time"), ("aiur", "fri-verifier-execute-time"),
+   ("aiur", "join-execute-time"),
    ("aiur", "ixvm-throughput"), ("aiur", "fri-verifier-throughput")]
 
 /-- Canonical units per measure slug, asserted on every sync: bencher
diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean
index c9a3caba1..959b4e514 100644
--- a/Ix/Cli/CheckCmd.lean
+++ b/Ix/Cli/CheckCmd.lean
@@ -34,6 +34,7 @@ public import Ix.Meta
 public import Ix.Store
 public import Ix.Cli.NameResolve
 public import Ix.Benchmark.Results
+public import Ix.KernelCheck
 public import Ix.TracingTexray
 
 public section
@@ -110,6 +111,43 @@ def emitStats (compiled : Aiur.CompiledToplevel)
     try Aiur.printStats stats
     finally let _ ← IO.setStdout old
 
+/-- Append per-constant virtual-gas costs from an execution's
+    `QueryRecordHandle` to `out`: one `<addr_hex> <vspan> <mult> [name]`
+    line per constrained `check_const` query. The address is recovered by
+    dereferencing the `Addr` argument — the LAST input slot, since `ci`
+    is passed flattened by value — through `memory[32]`; `vspan` is the
+    constant's standalone check cost within its shard (memo hits replay
+    the callee's recorded span). Order-independent within a partition,
+    but NOT exact across partitions: a callee owned by a foreign shard
+    is assumed rather than replayed, so its span drops out of its
+    callers' rows (measured: ~10% of a 360-const fixture's rows shift
+    between a 1-shard and a 4-shard partition, a few by >2x). Schedule
+    off a profile measured under the partition being scheduled.
+    Requires the execution to have run with `profile := true`, else
+    every span reads 0. -/
+def dumpProfile (compiled : Aiur.CompiledToplevel)
+    (record : Aiur.QueryRecordHandle) (out : String)
+    (nameOf : Address → Option Ix.Name) : IO Unit := do
+  let some idx := compiled.getFuncIdx `check_const
+    | IO.eprintln "--profile: no `check_const` in compiled toplevel"
+  let addrPos := compiled.bytecode.functions[idx]!.layout.inputSize - 1
+  let mut block := ""
+  for i in [0 : record.fnLen idx] do
+    let mult := record.fnMult idx i
+    if mult != 0 then
+      let key := record.fnKey idx i
+      if let some addrG := key[addrPos]? then
+        let limbs := record.memKey 32 addrG.val.toNat
+        let addr : Address := ⟨.mk <| limbs.map fun g => g.val.toUInt8⟩
+        let name := (nameOf addr).map (s!" {·}") |>.getD ""
+        block := block ++ s!"{addr} {record.fnVspan idx i} {mult}{name}\n"
+  -- One buffered write per execution: concurrent shard tasks (whole
+  -- partition mode) append to the same file, and a single O_APPEND
+  -- write keeps each shard's block from interleaving mid-line.
+  let h ← IO.FS.Handle.mk out .append
+  h.putStr block
+  h.flush
+
 /-- What a single `runOne` invocation is targeting.
 
     * `addr`: full-closure `Claim.check addr none` — dispatch via
@@ -197,7 +235,9 @@ def runBatchCheck (ixePath : String) (names : List String) (jobs : Nat)
     The `envHandle?` is `none` only for `.leanW` targets (`--interp`
     fallback); the addr/shard arms require it. -/
 def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool)
-    (statsOut : Option String) (useBytecode : Bool)
+    (statsOut : Option String)
+    (profile? : Option (String × (Address → Option Ix.Name)))
+    (useBytecode : Bool)
     (envHandle? : Option Aiur.EnvHandle)
     (target : Target) (label : String) : IO UInt32 := do
   IO.println s!"Typechecking {label}"
@@ -207,25 +247,28 @@ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool)
     let mut blob := ByteArray.empty
     for x in owned do blob := blob ++ x.hash
     pure blob
+  let profile := profile?.isSome
   let res :=
     match target, envHandle? with
     | .addr a, some envHandle =>
-      compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash useBytecode
+      compiled.bytecode.checkAddrWithEnvFull funIdx envHandle a.hash useBytecode profile
     | .shard owned, some envHandle =>
-      compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) useBytecode
+      compiled.bytecode.shardCheckWithEnvFull funIdx envHandle (buildBlob owned) useBytecode profile
     | .leanW witness, _ =>
       if useBytecode then
-        compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer
+        compiled.bytecode.executeFull funIdx witness.input witness.inputIOBuffer profile
       else
-        compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer
+        compiled.bytecode.executeIxVMFull funIdx witness.input witness.inputIOBuffer profile
     | _, none =>
       .error "internal: addr/shard target with no envHandle"
   match res with
   | .error e =>
     IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}"
     return 1
-  | .ok (_output, _ioBuffer, queryCounts) =>
-    if printStats then emitStats compiled queryCounts statsOut
+  | .ok r =>
+    if printStats then emitStats compiled r.queryCounts statsOut
+    if let some (out, nameOf) := profile? then
+      dumpProfile compiled r.record out nameOf
     pure 0
 
 /-- Run a single witness through the Aiur interpreter (richer errors). -/
@@ -419,6 +462,10 @@ private def ixesU32 : IxesP UInt32 := do
   let a ← ixesU8; let b ← ixesU8; let c ← ixesU8; let d ← ixesU8
   pure (a.toUInt32 ||| (b.toUInt32 <<< 8) ||| (c.toUInt32 <<< 16) ||| (d.toUInt32 <<< 24))
 
+private def ixesU64 : IxesP UInt64 := do
+  let lo ← ixesU32; let hi ← ixesU32
+  pure (lo.toUInt64 ||| (hi.toUInt64 <<< 32))
+
 private def ixesSkip (n : Nat) : IxesP Unit := do
   let (b, p) ← get
   if p + n ≤ b.size then modify (fun _ => (b, p + n)) else throw s!"ixes: truncated (skip {n})"
@@ -428,34 +475,168 @@ private def ixesAddr : IxesP Address := do
   if p + 32 ≤ b.size then modify (fun _ => (b, p + 32)); pure ⟨b.extract p (p + 32)⟩
   else throw "ixes: truncated (expected a 32-byte address)"
 
-/-- Parse every shard's owned block addresses from a serialized `.ixes`
+/-- The binary bisection tree stored at the tail of a `.ixes` manifest. Its
+leaves are shard ids; internal nodes prescribe the aggregation order that
+minimizes how long cross-shard assumptions remain live. -/
+inductive AggregationTree where
+  | leaf (shard : Nat)
+  | node (left right : AggregationTree)
+  deriving BEq, Repr, Inhabited
+
+namespace AggregationTree
+
+partial def leaves : AggregationTree → Array Nat
+  | .leaf shard => #[shard]
+  | .node left right => left.leaves ++ right.leaves
+
+/-- A legacy fallback for manifests written before the optional bisection-tree
+tail existed. Leaves remain in ascending shard order. -/
+partial def balancedRange (start count : Nat) : AggregationTree :=
+  if count ≤ 1 then .leaf start
+  else
+    let leftCount := count / 2
+    .node (balancedRange start leftCount)
+      (balancedRange (start + leftCount) (count - leftCount))
+
+/-- One post-order binary aggregation operation. Join child indices always
+refer to earlier plan slots, and the final slot is the root. -/
+inductive FoldOp where
+  | leaf (shard : Nat)
+  | join (left right : Nat)
+  deriving BEq, Repr
+
+/-- Lower a bisection tree to the slot plan consumed by the binary join host
+driver. -/
+partial def foldPlan (tree : AggregationTree) : Array FoldOp :=
+  (go tree #[]).2
+where
+  go (node : AggregationTree) (ops : Array FoldOp) : Nat × Array FoldOp :=
+    match node with
+    | .leaf shard => (ops.size, ops.push (.leaf shard))
+    | .node left right =>
+      let (leftIdx, ops) := go left ops
+      let (rightIdx, ops) := go right ops
+      (ops.size, ops.push (.join leftIdx rightIdx))
+
+/-- Drop removed shard leaves, contract unary nodes, and rewrite retained shard
+ids to their dense indices in a pruned manifest view. The input tree has
+already passed `validateAggregationTree`, so an out-of-range mapping entry is
+an internal inconsistency rather than untrusted manifest input. -/
+partial def pruneAndRemap (remap : Array (Option Nat)) :
+    AggregationTree → Option AggregationTree
+  | .leaf shard => (remap[shard]?).join.map .leaf
+  | .node left right =>
+    match pruneAndRemap remap left, pruneAndRemap remap right with
+    | some left, some right => some (.node left right)
+    | some tree, none | none, some tree => some tree
+    | none, none => none
+
+end AggregationTree
+
+structure IxesManifestView where
+  shards : Array (Array Address)
+  /-- Original manifest shard id for each (possibly pruned) dense array slot. -/
+  shardIds : Array Nat
+  aggregationTree : AggregationTree
+  /-- Per dense slot, the analytic prover peak (bytes) a previous run measured
+  for that shard's executed record — the manifest's trailing measured-peaks
+  section — or `0` when it was never measured (planner output, or a manifest
+  written before the section existed). -/
+  measuredPeakBytes : Array Nat
+  deriving BEq, Repr
+
+private partial def ixesAggregationTree : IxesP AggregationTree := do
+  match ← ixesU8 with
+  | 0 => pure (.leaf (← ixesU32).toNat)
+  | 1 => pure (.node (← ixesAggregationTree) (← ixesAggregationTree))
+  | tag => throw s!"ixes: invalid aggregation-tree tag {tag.toNat}"
+
+private def validateAggregationTree (tree : AggregationTree)
+    (numShards : Nat) : Except String Unit := do
+  let leaves := tree.leaves
+  if leaves.size != numShards then
+    throw s!"ixes: aggregation tree has {leaves.size} leaves for {numShards} shards"
+  let mut seen : Std.HashSet Nat := {}
+  for shard in leaves do
+    if shard ≥ numShards then
+      throw s!"ixes: aggregation tree leaf {shard} is out of range"
+    if seen.contains shard then
+      throw s!"ixes: aggregation tree repeats shard {shard}"
+    seen := seen.insert shard
+
+/-- Parse every shard's owned block addresses and aggregation tree from a
+serialized `.ixes`
     manifest (`ShardManifest::to_bytes`, `src/ix/shard.rs`):
     magic(8) ‖ total_cross_ingress(u128) ‖ num_shards(u32) ‖ per shard
     { id(u32) ‖ heartbeats(u64) ‖ own_size(u64) ‖ cross_ingress(u64) ‖
       assumption_root(u8 tag + 32?) ‖ blocks(u32 len + 32·len) ‖
       foreign_blocks(u32 len + 32·len) }.
-    Bounds-checked: a truncated/malformed file yields `.error`, never a panic. -/
-def parseIxesAllShards (bytes : ByteArray) : Except String (Array (Array Address)) :=
-  let go : IxesP (Array (Array Address)) := do
+    The optional trailing tree uses preorder `leaf(0,id:u32)` /
+    `node(1,left,right)` encoding. Legacy manifests with no tree (or an explicit
+    zero presence byte) receive a balanced ascending-id fallback. After the tree
+    an optional measured-peaks section follows: presence byte, then one `u64`
+    analytic prover peak per shard in id order (`0` = unmeasured); absent on
+    manifests written before it existed. Anything after the last known section
+    is an error. Bounds-checked: a truncated/malformed file yields `.error`,
+    never a panic. -/
+def parseIxesManifest (bytes : ByteArray) : Except String IxesManifestView :=
+  let go : IxesP IxesManifestView := do
     let m0 ← ixesU8; let m1 ← ixesU8; let m2 ← ixesU8; let m3 ← ixesU8
     if !(m0 == 0x49 && m1 == 0x58 && m2 == 0x45 && m3 == 0x53) then
       throw "not an .ixes file (bad magic)"
     ixesSkip 4    -- rest of the 8-byte magic
     ixesSkip 16   -- total_cross_ingress (u128)
     let n ← ixesU32
+    if n == 0 then throw "ixes: manifest contains no shards"
     let mut shards : Array (Array Address) := #[]
-    for _ in [0:n.toNat] do
-      ixesSkip (4 + 8 + 8 + 8)  -- id + heartbeats + own_size + cross_ingress
-      if (← ixesU8) == 1 then ixesSkip 32  -- assumption_root present
+    for shardIdx in [0:n.toNat] do
+      let shardId ← ixesU32
+      if shardId.toNat != shardIdx then
+        throw s!"ixes: shard entry {shardIdx} has id {shardId.toNat}"
+      ixesSkip (8 + 8 + 8)  -- heartbeats + own_size + cross_ingress
+      match ← ixesU8 with
+      | 0 => pure ()
+      | 1 => ixesSkip 32  -- assumption_root present
+      | tag => throw s!"ixes: invalid assumption-root presence tag {tag.toNat}"
       let blen ← ixesU32
       let mut blocks : Array Address := #[]
       for _ in [0:blen.toNat] do
         blocks := blocks.push (← ixesAddr)
       ixesSkip ((← ixesU32).toNat * 32)  -- skip foreign_blocks
       shards := shards.push blocks
-    pure shards
+    let (buffer, position) ← get
+    let tree ← if position == buffer.size then
+        pure (AggregationTree.balancedRange 0 n.toNat)
+      else
+        match ← ixesU8 with
+        | 0 => pure (AggregationTree.balancedRange 0 n.toNat)
+        | 1 => ixesAggregationTree
+        | tag => throw s!"ixes: invalid aggregation-tree presence tag {tag.toNat}"
+    validateAggregationTree tree n.toNat
+    let (buffer, position) ← get
+    let measuredPeakBytes ← if position == buffer.size then
+        pure (Array.replicate n.toNat 0)
+      else
+        match ← ixesU8 with
+        | 0 => pure (Array.replicate n.toNat 0)
+        | 1 => do
+          let mut peaks : Array Nat := #[]
+          for _ in [0:n.toNat] do
+            peaks := peaks.push (← ixesU64).toNat
+          pure peaks
+        | tag => throw s!"ixes: invalid measured-peaks presence tag {tag.toNat}"
+    let (buffer, position) ← get
+    if position != buffer.size then
+      throw s!"ixes: {buffer.size - position} trailing bytes after the measured-peaks section"
+    pure { shards, shardIds := Array.range n.toNat, aggregationTree := tree,
+           measuredPeakBytes }
   go.run' (bytes, 0)
 
+/-- Backward-compatible shard-only view used by check/prove/verify paths that
+do not yet consume the aggregation order. -/
+def parseIxesAllShards (bytes : ByteArray) : Except String (Array (Array Address)) :=
+  (parseIxesManifest bytes).map (·.shards)
+
 /-- The check-schedule block address of a constant: a projection collapses
     to its SCC/Muts wrapper (`p.block`); everything else is its own block.
     Mirrors `check_schedule_block_addr` (`src/ffi/kernel.rs`). -/
@@ -467,26 +648,109 @@ private def blockAddrOf (addr : Address) (c : Ixon.Constant) : Address :=
   | .dPrj prj => prj.block
   | _ => addr
 
-/-- Owned constants of a shard: every env constant whose check-schedule block
-    is in `blocks`.
+/-- Each block address mapped to the index of the list owning it. -/
+def blockIndexOf (lists : Array (Array Address)) :
+    Std.HashMap Address Nat :=
+  (lists.mapIdx fun k l => (k, l)).foldl (init := {}) fun m (k, l) =>
+    l.foldl (fun m blk => m.insert blk k) m
+
+/-- Owned constants per entry, in ONE env pass: `result[k]` is every env
+    constant whose check-schedule block is in `lists[k]`, in
+    env-iteration order (identical to a per-entry filter, so claim
+    digests are unchanged). Per-entry filtering rescans all consts each
+    call — at env scale (241 shards × 688k consts) that is ~30 min of
+    setup, vs seconds here.
+
+    Constants whose bytes do not parse are owned by NOBODY. That is safe
+    only because `shardsCover` fails the run when any exist; without
+    that gate a silent skip here means a constant no shard ever
+    checks. -/
+def ownedConstsPer (ixonEnv : Ixon.Env) (lists : Array (Array Address)) :
+    Array (Array Address) :=
+  let blockTo := blockIndexOf lists
+  ixonEnv.consts.fold (init := Array.replicate lists.size #[])
+    fun owned addr lc =>
+      match lc.get? with
+      | none => owned
+      | some c =>
+        match blockTo.get? (blockAddrOf addr c) with
+        | some k => owned.modify k (·.push addr)
+        | none => owned
 
-    Constants whose bytes do not parse are skipped and therefore owned by
-    NOBODY. That is safe only because `shardsCover` fails the run when any
-    exist, so this is never reached with one present; without that gate a
-    silent skip here means a constant no shard ever checks. -/
-def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) : Array Address := Id.run do
-  let blockSet : Std.HashSet Address := blocks.foldl (·.insert ·) {}
-  let mut o : Array Address := #[]
+/-- Owned constants of one shard: `ownedConstsPer` over a singleton. -/
+def ownedConstsForBlocks (ixonEnv : Ixon.Env) (blocks : Array Address) :
+    Array Address :=
+  (ownedConstsPer ixonEnv #[blocks])[0]!
+
+/-- Partition a shard's already-known `owned` constants among `parts`
+    (block lists) by check-schedule block: one pass over the owned
+    consts, none over the env — the split-time companion of
+    `ownedConstsPer`, whose full env pass runs once per run. -/
+def partitionOwned (ixonEnv : Ixon.Env) (owned : Array Address)
+    (parts : Array (Array Address)) : Array (Array Address) :=
+  let blockTo := blockIndexOf parts
+  owned.foldl (init := Array.replicate parts.size #[]) fun acc a =>
+    match (ixonEnv.consts.get? a).bind (·.get?) with
+    | none => acc
+    | some c =>
+      match blockTo.get? (blockAddrOf a c) with
+      | some k => acc.modify k (·.push a)
+      | none => acc
+
+/-- Count each shard's owned constants in one environment pass. Callers first
+run `shardsCover`, so every check-schedule block has exactly one owner. This is
+the subject-leaf count used by aggregate structural-threshold scheduling. -/
+def ownedConstCountsForShards (ixonEnv : Ixon.Env)
+    (shards : Array (Array Address)) : Array Nat := Id.run do
+  let mut blockToShard : Std.HashMap Address Nat := {}
+  for (blocks, shard) in shards.mapIdx fun shard blocks => (blocks, shard) do
+    for block in blocks do
+      blockToShard := blockToShard.insert block shard
+  let mut counts := Array.replicate shards.size 0
   for (addr, lc) in ixonEnv.consts do
     let some c := lc.get? | continue
-    if blockSet.contains (blockAddrOf addr c) then o := o.push addr
-  return o
+    let some shard := blockToShard.get? (blockAddrOf addr c) | continue
+    counts := counts.modify shard (· + 1)
+  return counts
+
+/-- Remove manifest shards that provably own no environment constants, then
+contract and densely reindex the corresponding aggregation-tree leaves.
+
+Callers must run `shardsCover` on the unpruned view first. That gate establishes
+that every constant is owned exactly once; the zero counts here therefore prove
+that dropping these leaves cannot omit a checked subject. `shardIds` preserves
+the original ids for diagnostics and for matching legacy manifests. -/
+def IxesManifestView.pruneEmpty (view : IxesManifestView)
+    (ixonEnv : Ixon.Env) : Except String (IxesManifestView × Array Nat) := do
+  if view.shards.size != view.shardIds.size then
+    throw "ixes: internal shard/id cardinality mismatch"
+  let counts := ownedConstCountsForShards ixonEnv view.shards
+  let mut remap : Array (Option Nat) := Array.replicate view.shards.size none
+  let mut shards : Array (Array Address) := #[]
+  let mut shardIds : Array Nat := #[]
+  let mut measuredPeakBytes : Array Nat := #[]
+  let mut keptCounts : Array Nat := #[]
+  for (count, oldIdx) in counts.mapIdx fun oldIdx count => (count, oldIdx) do
+    if count != 0 then
+      let some blocks := view.shards[oldIdx]?
+        | throw s!"ixes: internal missing shard {oldIdx}"
+      let some originalId := view.shardIds[oldIdx]?
+        | throw s!"ixes: internal missing shard id {oldIdx}"
+      remap := remap.set! oldIdx (some shards.size)
+      shards := shards.push blocks
+      shardIds := shardIds.push originalId
+      measuredPeakBytes := measuredPeakBytes.push ((view.measuredPeakBytes[oldIdx]?).getD 0)
+      keptCounts := keptCounts.push count
+  let some aggregationTree := view.aggregationTree.pruneAndRemap remap
+    | throw "aggregate: manifest has no shard owning an environment constant"
+  pure ({ shards, shardIds, aggregationTree, measuredPeakBytes }, keptCounts)
 
 /-- The `CheckEnv` claim digest a shard's proof commits to — reconstructed
     deterministically from the env + the shard's owned blocks. Matches the
     digest `prove --shard K` produced, so a proof can be bound to its shard. -/
 def shardClaimDigest (ixonEnv : Ixon.Env) (blocks : Array Address) : Except String Address := do
-  let (claim, _, _) ← IxVM.ClaimHarness.shardCheckEnvClaim ixonEnv (ownedConstsForBlocks ixonEnv blocks)
+  let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv
+    (ownedConstsForBlocks ixonEnv blocks)
   pure (Address.blake3 (Ix.Claim.ser claim))
 
 /-- Load the `.ixe` env and the `.ixes` shard partition together (each file
@@ -516,8 +780,8 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat)
     the pre-built envHandle so all shards in an all-shards run share
     one env parse. -/
 def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel)
-    (printStats : Bool) (statsOut : Option String) (useBytecode : Bool)
-    (shapes : Array Aiur.CircuitShape)
+    (printStats : Bool) (statsOut : Option String) (profileOut : Option String)
+    (useBytecode : Bool)
     (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do
   let owned := ownedConstsForBlocks ixonEnv blocks
   IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \
@@ -529,19 +793,14 @@ def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledTo
   let mut blob := ByteArray.empty
   for a in owned do
     blob := blob ++ a.hash
-  match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob useBytecode with
+  match compiled.bytecode.shardCheckWithEnvFull funIdx envHandle blob useBytecode profileOut.isSome with
   | .error e =>
     IO.eprintln s!"{label}: IxVM-native shard check error: {e}"
     return 1
-  | .ok (_output, _ioBuffer, queryCounts) =>
-    -- Prover RAM projection from this shard's executed heights: the
-    -- input to split/merge decisions against a prover budget.
-    let stats := Aiur.computeStats compiled queryCounts shapes
-    let bytes := stats.projectedProverBytes
-    let gib := Float.ofNat bytes / 1073741824.0
-    IO.println s!"[shard {shardK}] projected prover RAM: \
-      {gib} GiB (padded committed traces × blowup)"
-    if printStats then emitStats compiled queryCounts statsOut
+  | .ok r =>
+    if printStats then emitStats compiled r.queryCounts statsOut
+    if let some out := profileOut then
+      dumpProfile compiled r.record out (ixonEnv.addrToName.get? ·)
     pure 0
 
 /-- Manifest-driven check/prove of one shard `shardK` of the partition. -/
@@ -557,7 +816,8 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat)
     once for this one call. -/
 def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat)
     (compiled : Aiur.CompiledToplevel) (printStats : Bool)
-    (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do
+    (statsOut : Option String) (profileOut : Option String)
+    (useBytecode : Bool) : IO UInt32 := do
   match (← loadEnvAndShards manifestPath ixePath) with
   | .error e => IO.eprintln e; return 1
   | .ok (ixonEnv, shards) => match shards[shardK]? with
@@ -566,9 +826,8 @@ def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat)
       let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with
         | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1
         | .ok h => pure h
-      let shapes := Aiur.circuitShapes compiled.bytecode
-        Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
-      runShardOwnedNative envHandle compiled printStats statsOut useBytecode shapes ixonEnv blocks shardK
+      runShardOwnedNative envHandle compiled printStats statsOut profileOut
+        useBytecode ixonEnv blocks shardK
 
 /-- Coverage check over already-loaded env + shards: every constant's
     check-schedule block is owned by **exactly one** shard. That is the whole
@@ -618,6 +877,189 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool
     IO.println s!"[shards] OK: partition covers all {ixonEnv.consts.size} consts, disjoint"
   pure ok
 
+/-- Cut `blocks` into contiguous, nonempty, roughly equal-count parts
+    (`p` clamped to `[2, blocks.size]` — a rejection always needs at
+    least two parts, and the block list caps how many a cut can
+    produce). Rows are what the prover-RAM model responds to, and equal
+    block counts are the measured-best proxy for equal rows
+    (equal-vspan cuts lost on parts, depth and executions on every env
+    tried). Shared by the prove split recursion and the check wave
+    loop. -/
+def cutBlocks (blocks : Array Address) (p : Nat) : Array (Array Address) :=
+  let p := min (max p 2) blocks.size
+  (Array.range p).map fun i =>
+    blocks.extract (blocks.size * i / p) (blocks.size * (i + 1) / p)
+
+/-- Measured-peaks blob for the manifest emit: one 8-byte LE value per
+    shard, in shard order. -/
+def peaksBlob (peaks : Array Nat) : ByteArray :=
+  peaks.foldl (init := ByteArray.empty) fun blob pk =>
+    blob ++ pk.toUInt64.toLEBytes
+
+/-- Wire encoding shared by the shard batch FFI and the manifest emit:
+    per entry, a 4-byte LE count followed by the 32-byte addresses. -/
+def addrListsBlob (lists : Array (Array Address)) : ByteArray :=
+  lists.foldl (init := ByteArray.empty) fun blob l =>
+    l.foldl (fun b a => b ++ a.hash) (blob ++ l.size.toUInt32.toLEBytes)
+
+/-- One leaf of a source manifest cut into parts, as the prove and check
+    split loops produce it: the parts' block lists in block order, each
+    with the analytic prover peak measured on its executed record
+    (`0` = unmeasured). -/
+structure LeafRefinement where
+  shard : Nat
+  parts : Array (Array Address × Nat)
+
+/-- Wire encoding of `Aiur.shardManifestRefine`'s refinements argument:
+    `count(u32)`, then per refined leaf `id(u32) ‖ nparts(u32)` and per
+    part `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`. -/
+def refinementsBlob (rs : Array LeafRefinement) : ByteArray :=
+  rs.foldl (init := rs.size.toUInt32.toLEBytes) fun blob r =>
+    r.parts.foldl
+      (init := blob ++ r.shard.toUInt32.toLEBytes ++ r.parts.size.toUInt32.toLEBytes)
+      fun blob (blocks, peak) =>
+        (blocks.foldl (fun b a => b ++ a.hash) (blob ++ blocks.size.toUInt32.toLEBytes))
+          ++ peak.toUInt64.toLEBytes
+
+/-- Group per-leaf run results `(shard, parts)` over the `n` leaves of a
+    source manifest into the leaves that split (≥ 2 parts) and the
+    measured peaks of the leaves that did not (`0` where a leaf was not
+    run). -/
+def refinementsOfRuns (n : Nat)
+    (runs : Array (Nat × Array (Array Address × Nat))) :
+    Array LeafRefinement × Array Nat :=
+  runs.foldl (init := (#[], Array.replicate n 0)) fun (rs, measured) (k, parts) =>
+    if parts.size > 1 then (rs.push { shard := k, parts }, measured)
+    else match parts[0]? with
+      | some (_, peak) => (rs, if k < measured.size then measured.set! k peak else measured)
+      | none => (rs, measured)
+
+/-- Decode the new-id table `Aiur.shardManifestRefine` returns:
+    `count(u32)`, then per refinement `n(u32) ‖ n × id(u32)`. Malformed
+    input yields the ids decoded so far, never a panic. -/
+def decodeIdTable (bytes : ByteArray) : Array (Array Nat) := Id.run do
+  let u32At (i : Nat) : Option Nat :=
+    if i + 4 ≤ bytes.size then
+      some (bytes[i]!.toNat ||| (bytes[i+1]!.toNat <<< 8)
+        ||| (bytes[i+2]!.toNat <<< 16) ||| (bytes[i+3]!.toNat <<< 24))
+    else none
+  let some count := u32At 0 | return #[]
+  let mut pos := 4
+  let mut table : Array (Array Nat) := #[]
+  for _ in [0:count] do
+    let some n := u32At pos | return table
+    pos := pos + 4
+    let mut ids : Array Nat := #[]
+    for _ in [0:n] do
+      let some id := u32At pos | return table
+      ids := ids.push id
+      pos := pos + 4
+    table := table.push ids
+  return table
+
+/-- Emit the partition a run actually validated as a refinement of the
+    manifest it started from — the shared tail of `ix prove --out-ixes`
+    and `ix check --ram-budget --out-ixes`. Untouched leaves keep their
+    records, ids and tree positions (`Aiur.shardManifestRefine`); a leaf
+    that split becomes a subtree over its parts, part 0 keeping the leaf's
+    id and later parts taking fresh ids after the last existing one.
+    `measured` carries the peaks of the leaves that ran unsplit. Skipped
+    with a note when any shard failed: a refined manifest describes a
+    fully-validated partition. Returns the parts' new ids per refinement. -/
+def emitRefinedManifest (tag : String) (envHandle : Aiur.EnvHandle)
+    (sourcePath out : String) (refinements : Array LeafRefinement)
+    (measured : Array Nat) (failures : Nat) : IO (Array (Array Nat)) := do
+  if failures == 0 then
+    let ids ← Aiur.shardManifestRefine envHandle sourcePath
+      (refinementsBlob refinements) (peaksBlob measured) out
+    IO.println s!"[{tag}] refined manifest → {out} \
+      ({refinements.size} leaf/leaves split)"
+    pure (decodeIdTable ids)
+  else
+    IO.eprintln s!"--out-ixes {out} skipped: {failures} failure(s)"
+    pure #[]
+
+/-- What a batch run is asked to do beyond the plain check. -/
+structure AuditOptions where
+  /-- Leaves to execute in wave 0; `none` = every leaf of the manifest. -/
+  selection : Option (Array Nat) := none
+  /-- Decide, once the env and every leaf's owned constants are loaded,
+      which selected leaves a verified proof already covers: they are
+      reported `proven-kept`, never executed and never split (the
+      shard-proof index guard of `ix shard refine`). Receives the env, the
+      leaves' block lists, their owned constants, and the selected ids. -/
+  provenGuard : Option (Ixon.Env → Array (Array Address) → Array (Array Address)
+    → Array Nat → IO (Std.HashMap Nat Address)) := none
+  /-- Write the provisional JSON report (`ix-refine/0`) here. -/
+  report : Option String := none
+  /-- `true` (`ix shard refine`): write `--out-ixes` even when some leaves
+      failed — they stay unchanged — and exit 2. `false` (`ix check`): skip
+      the manifest on any failure. -/
+  emitOnFailure : Bool := false
+  /-- The invoking command line, recorded in the report. -/
+  command : String := ""
+  /-- How the budget was chosen (`flag` or `detected`), for the report. -/
+  budgetSource : String := "flag"
+
+/-- One settled part of a leaf's cascade, for the manifest and the report. -/
+structure PartReport where
+  label : String
+  blocks : Array Address
+  owned : Array Address
+  peak : Nat
+  error : String := ""
+
+/-- Claim digest of a leaf from its already-known owned constants (no env
+    rescan): the digest `ix prove` persists and `ix aggregate` matches on. -/
+def claimDigestOfOwned (ixonEnv : Ixon.Env) (owned : Array Address) :
+    Except String Address := do
+  let (claim, _) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned
+  pure (Address.blake3 (Ix.Claim.ser claim))
+
+/-- `K`, `a-b`, or a comma list of those: the leaf ids a run is restricted
+    to, sorted and deduplicated. -/
+def parseShardSelection (s : String) : Except String (Array Nat) := do
+  let mut ids : Array Nat := #[]
+  for piece in s.splitOn "," do
+    let piece := piece.trimAscii.toString
+    if piece.isEmpty then continue
+    match piece.splitOn "-" with
+    | [one] =>
+      let some k := one.trimAscii.toString.toNat?
+        | throw s!"--shards: not a shard id: `{piece}`"
+      ids := ids.push k
+    | [lo, hi] =>
+      let some a := lo.trimAscii.toString.toNat?
+        | throw s!"--shards: not a range: `{piece}`"
+      let some b := hi.trimAscii.toString.toNat?
+        | throw s!"--shards: not a range: `{piece}`"
+      if b < a then throw s!"--shards: empty range `{piece}`"
+      for k in [a:b+1] do ids := ids.push k
+    | _ => throw s!"--shards: malformed `{piece}` (use K, a-b, or a comma list)"
+  if ids.isEmpty then throw "--shards: empty selection"
+  let sorted := ids.qsort (· < ·)
+  pure (sorted.foldl (fun acc k => if acc.back? == some k then acc else acc.push k) #[])
+
+private def fileDigest (path : String) : IO (Option (String × Nat)) := do
+  try
+    let bytes ← IO.FS.readBinFile path
+    pure (some (toString (Address.blake3 bytes), bytes.size))
+  catch _ => pure none
+
+private def gitRevision : IO String := do
+  try
+    let out ← IO.Process.output { cmd := "git", args := #["rev-parse", "HEAD"] }
+    pure (if out.exitCode == 0 then out.stdout.trimAscii.toString else "unknown")
+  catch _ => pure "unknown"
+
+private def fileJson (path : String) (digest : Option (String × Nat))
+    (shards : Option Nat) : Lean.Json :=
+  Lean.Json.mkObj ([("path", Lean.Json.str path)]
+    ++ (match digest with
+        | some (h, n) => [("blake3", Lean.Json.str h), ("bytes", Lean.toJson n)]
+        | none => [])
+    ++ (match shards with | some n => [("shards", Lean.toJson n)] | none => []))
+
 /-- Whole-partition check as ONE Rust rayon batch: work-stealing across
     shards, no chunk barriers (measured 2.3–2.5x faster than the
     per-shard Lean-task scheduler it replaced, whose chunk-of-N full
@@ -628,10 +1070,18 @@ def shardsCover (ixonEnv : Ixon.Env) (shards : Array (Array Address)) : IO Bool
     under it) decisions. Builds the `EnvHandle` ONCE, shared by every
     shard. Coverage-gates the manifest before running any shard — exit
     0 has to mean "every env const was checked by some shard", same
-    soundness contract as `runShardCheckAll`. -/
+    soundness contract as `runShardCheckAll`.
+
+    `opts` turns the batch into an audit: a selection of leaves, the
+    proven-leaf guard, a JSON report, and `ix shard refine`'s failure
+    policy. -/
 def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat)
     (compiled : Aiur.CompiledToplevel) (useBytecode : Bool)
-    (json? : Option (String × String) := none) : IO UInt32 := do
+    (profileOut : Option String)
+    (json? : Option (String × String))
+    (maxRamBytes : Nat) (outIxes : Option String)
+    (opts : AuditOptions := {}) :
+    IO UInt32 := do
   -- The row's peak-rss needs the process-tree RSS sampler running
   -- (`peakTreeRssBytes` reports 0 otherwise); started before the env
   -- load so the peak covers the whole run, like `check-rs`.
@@ -640,76 +1090,278 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat)
   | .error e => IO.eprintln e; return 1
   | .ok (ixonEnv, shards) =>
     if !(← shardsCover ixonEnv shards) then return 1
+    let selected : Array Nat ← match opts.selection with
+      | none => pure (Array.range shards.size)
+      | some sel =>
+        if let some k := sel.find? (· ≥ shards.size) then
+          IO.eprintln s!"--shards: shard {k} out of range ({shards.size} shards)"
+          return 1
+        pure sel
+    let selectedSet : Std.HashSet Nat := selected.foldl (·.insert ·) {}
     let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with
       | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1
       | .ok h => pure h
     let funIdx := compiled.getFuncIdx `verify_claim |>.get!
     let jobs := jobs?.getD 0
-    -- Assign every const to its shard in ONE env pass. Calling
-    -- `ownedConstsForBlocks` per shard rescans all consts each time —
-    -- at env scale (241 shards × 688k consts) that is ~30 min of setup.
-    -- Each shard's array keeps env-iteration order, identical to what
-    -- the per-shard filter produces, so claim digests are unchanged.
-    let mut blockToShard : Std.HashMap Address Nat := {}
-    for (blocks, k) in shards.mapIdx (fun k b => (b, k)) do
-      for blk in blocks do blockToShard := blockToShard.insert blk k
-    let mut ownedPerShard : Array (Array Address) := Array.replicate shards.size #[]
-    for (addr, lc) in ixonEnv.consts do
-      let some c := lc.get? | continue
-      match blockToShard.get? (blockAddrOf addr c) with
-      | some k => ownedPerShard := ownedPerShard.modify k (·.push addr)
-      | none => pure ()
-    let mut blob := ByteArray.empty
-    for owned in ownedPerShard do
-      let n := owned.size.toUInt32
-      blob := blob.push n.toUInt8
-      blob := blob.push (n >>> 8).toUInt8
-      blob := blob.push (n >>> 16).toUInt8
-      blob := blob.push (n >>> 24).toUInt8
-      for a in owned do blob := blob ++ a.hash
-    IO.println s!"Typechecking {shards.size} shard(s) in one rayon \
-      batch, {jobs} thread(s) (0 = all)"
-    (← IO.getStdout).flush
-    let totalConsts := ownedPerShard.foldl (· + ·.size) 0
-    let start ← IO.monoMsNow
-    match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle blob
-        useBytecode jobs Aiur.defaultCommitmentParameters
-        Aiur.defaultFriParameters with
-    | .error e => IO.eprintln s!"shard batch: {e}"; return 1
-    | .ok results =>
-      let elapsedMs := (← IO.monoMsNow) - start
-      let mut failures : Nat := 0
-      for k in [:results.size] do
-        let (err, peak) := results[k]!
-        if err.isEmpty then
-          let gib := Float.ofNat peak / 1073741824.0
-          IO.println s!"[shard {k}] ok, projected prover peak {gib} GiB"
-        else
-          IO.eprintln s!"[shard {k}] FAILED: {err}"
-          failures := failures + 1
-      -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`:
-      -- the measured window is the batch FFI call (env load and blob
-      -- setup are excluded, matching what the benchmark tracks — the
-      -- execution engine, not the loader).
-      if let some (path, key) := json? then
-        let secs := elapsedMs.toFloat / 1000.0
-        let tput := if elapsedMs > 0
-          then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0
-        let peakRss ← TracingTexray.peakTreeRssBytes
-        let status := if failures == 0 then "ok" else "rejected"
-        Ix.Benchmark.Results.writeRow path key status
-          [ ("constants", Lean.toJson totalConsts)
-          , ("shards", Lean.toJson results.size)
-          , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs)
-          , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput)
-          , ("peak-rss", Lean.toJson peakRss) ]
-      if failures == 0 then
-        IO.println s!"All {results.size} shard(s) passed"
-        return 0
-      IO.eprintln s!"{failures} of {results.size} shard(s) FAILED"
-      -- Under `--json` a kernel rejection is the benchmark's `rejected`
-      -- exit (the row is already written), same contract as `check-rs`.
-      return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1
+    -- `check_const`'s queries are what the weight rows are read from; a
+    -- toplevel without it can still check, just not profile.
+    let checkConstIdx := (compiled.getFuncIdx `check_const).getD 0
+    if profileOut.isSome && (compiled.getFuncIdx `check_const).isNone then
+      IO.eprintln "--profile: no `check_const` in compiled toplevel"
+    -- The whole run's ownership assignment: one env pass here, and every
+    -- later wave's parts inherit their parent's owned consts via
+    -- `partitionOwned` — no wave ever rescans the env.
+    let ownedAll := ownedConstsPer ixonEnv shards
+    -- Leaves a verified proof already covers stay exactly as they are.
+    let proven : Std.HashMap Nat Address ← match opts.provenGuard with
+      | none => pure {}
+      | some guard => guard ixonEnv shards ownedAll selected
+    if !proven.isEmpty then
+      IO.println s!"[audit] {proven.size} selected leaf/leaves already have a \
+        verified proof — kept unsplit"
+    let cutLabeled (origin : Nat) (label : String) (blocks owned : Array Address)
+        (p : Nat) : Array (Nat × String × Array Address × Array Address) :=
+      let parts := cutBlocks blocks p
+      (parts.zip (partitionOwned ixonEnv owned parts)).mapIdx
+        fun i (part, po) => (origin, s!"{label}.{i}", part, po)
+    -- One loop over execution waves. Wave 0 is the selected part of the
+    -- planned partition; with a budget every over-budget leaf is cut into
+    -- the peak model's suggested part count and the parts re-batched as
+    -- the next wave, until everything fits or is a single block. Without
+    -- a budget the FFI answers 1 part everywhere and the loop is a single
+    -- wave — the plain batch check. Waves after the first never profile:
+    -- wave 0 already carries one row per constant, measured under the
+    -- planned partition — the one schedulers consume.
+    let mut wave : Array (Nat × String × Array Address × Array Address) :=
+      selected.filterMap fun k =>
+        if proven.contains k then none
+        else (shards[k]?).bind fun b => (ownedAll[k]?).map fun o => (k, s!"{k}", b, o)
+    let executed := wave.size
+    let mut waveNum := 0
+    let mut failed : Array String := #[]
+    let mut final : Array (Array Address × Nat) := #[]
+    -- Per source leaf: its wave-0 peak, and the parts that ended its
+    -- cascade (fit, or failed) — what the manifest and the report describe.
+    let mut leafPeak : Std.HashMap Nat Nat := {}
+    let mut leafParts : Std.HashMap Nat (Array PartReport) := {}
+    let mut totalConsts := 0
+    let mut elapsedMs := 0
+    while wave.size > 0 do
+      if waveNum == 0 then
+        IO.println s!"Typechecking {wave.size} shard(s) in one rayon \
+          batch, {jobs} thread(s) (0 = all)"
+      else
+        IO.println s!"[wave {waveNum}] re-executing {wave.size} part(s)"
+      (← IO.getStdout).flush
+      let ownedPer := wave.map (·.2.2.2)
+      let start ← IO.monoMsNow
+      match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle
+          (addrListsBlob ownedPer) useBytecode jobs
+          Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
+          (profileOut.isSome && waveNum == 0) checkConstIdx maxRamBytes with
+      | .error e => IO.eprintln s!"shard batch (wave {waveNum}): {e}"; return 1
+      | .ok rs =>
+        if waveNum == 0 then
+          -- The bench row's measured window: the planned partition's
+          -- batch call, matching `check-rs`. Split waves are audit
+          -- extras outside the benchmarked engine window.
+          elapsedMs := (← IO.monoMsNow) - start
+          totalConsts := ownedPer.foldl (· + ·.size) 0
+        let mut next : Array (Nat × String × Array Address × Array Address) := #[]
+        for (r, origin, label, blocks, owned) in rs.zip wave do
+          let gib := toGib r.peakBytes
+          if waveNum == 0 then leafPeak := leafPeak.insert origin r.peakBytes
+          let mut settled : Option String := none
+          if !r.error.isEmpty then
+            IO.eprintln s!"[shard {label}] FAILED: {r.error}"
+            failed := failed.push s!"shard {label}: {r.error}"
+            settled := some r.error
+          else if r.suggestedParts <= 1 then
+            IO.println s!"[shard {label}] ok, projected prover peak {gib} GiB"
+            settled := some ""
+          else if blocks.size <= 1 then
+            IO.eprintln s!"[shard {label}] peak {gib} GiB over budget and a \
+              single block — cannot split"
+            failed := failed.push s!"shard {label}: single block over budget"
+            settled := some "single block over budget"
+          else
+            IO.println s!"[shard {label}] peak {gib} GiB over budget — cut \
+              into {r.suggestedParts}"
+            next := next ++ cutLabeled origin label blocks owned r.suggestedParts
+          if let some error := settled then
+            final := final.push (blocks, r.peakBytes)
+            leafParts := leafParts.insert origin ((leafParts.getD origin #[]).push
+              { label, blocks, owned, peak := r.peakBytes, error })
+        -- Weight rows are appended once, from wave 0: Rust already
+        -- reduced each shard's record under its own task, so nothing
+        -- here holds a record alive.
+        if waveNum == 0 then
+          if let some out := profileOut then
+            let h ← IO.FS.Handle.mk out .append
+            for r in rs do
+              h.putStr <| r.foldWeights "" fun acc addrBytes vspan mult =>
+                let addr : Address := ⟨addrBytes⟩
+                let name := (ixonEnv.addrToName.get? addr).map (s!" {·}") |>.getD ""
+                acc ++ s!"{addr} {vspan} {mult}{name}\n"
+            h.flush
+        wave := next
+        waveNum := waveNum + 1
+    let tag := if opts.emitOnFailure then "refine" else "split-audit"
+    let waves := if waveNum == 0 then 0 else waveNum - 1
+    if maxRamBytes > 0 then
+      IO.println s!"[{tag}] {final.size} part(s) from {executed} executed \
+        leaf/leaves ({shards.size} in the manifest), {waves} split wave(s), \
+        {failed.size} failure(s)"
+    -- A split leaf's parts in block order, whatever wave settled them.
+    let sortedParts (k : Nat) (parts : Array PartReport) : Array PartReport :=
+      let pos : Std.HashMap Address Nat :=
+        (((shards[k]?).getD #[]).mapIdx fun i a => (a, i)).foldl
+          (fun m (a, i) => m.insert a i) {}
+      let posOf (p : PartReport) : Nat := ((p.blocks[0]?).bind pos.get?).getD 0
+      parts.qsort fun a b => posOf a < posOf b
+    -- The refined partition — what this run actually validated — written
+    -- as a refinement of the manifest it started from: untouched leaves
+    -- keep their records, ids and tree positions; a failed leaf stays as
+    -- in the source.
+    let runs : Array (Nat × Array (Array Address × Nat)) :=
+      (Array.range shards.size).filterMap fun k =>
+        (leafParts.get? k).bind fun ps =>
+          if ps.any (·.error != "") then none
+          else some (k, (sortedParts k ps).map fun p => (p.blocks, p.peak))
+    let mut idTable : Array (Array Nat) := #[]
+    let mut wroteManifest := false
+    if let some out := outIxes then
+      if failed.isEmpty || opts.emitOnFailure then
+        let (refinements, measured) := refinementsOfRuns shards.size runs
+        idTable ← emitRefinedManifest tag envHandle manifestPath out
+          refinements measured 0
+        wroteManifest := true
+      else
+        IO.eprintln s!"--out-ixes {out} skipped: {failed.size} failure(s)"
+    if let some reportPath := opts.report then
+      -- New ids per split leaf, in refinement order (ascending leaf id).
+      let mut newIds : Std.HashMap Nat (Array Nat) := {}
+      for ((k, _), ids) in (runs.filter (·.2.size > 1)).zip idTable do
+        newIds := newIds.insert k ids
+      let digestJson (owned : Array Address) : Lean.Json :=
+        match claimDigestOfOwned ixonEnv owned with
+        | .ok d => Lean.Json.str (toString d)
+        | .error _ => Lean.Json.null
+      let mut leaves : Array Lean.Json := #[]
+      let mut failures : Array Lean.Json := #[]
+      for k in [0:shards.size] do
+        let blocks := (shards[k]?).getD #[]
+        let owned := (ownedAll[k]?).getD #[]
+        let inRun := proven.contains k || selectedSet.contains k
+        let base := [("id", Lean.toJson k), ("blocks", Lean.toJson blocks.size),
+          ("consts", Lean.toJson owned.size),
+          ("claim", if inRun then digestJson owned else Lean.Json.null),
+          ("predicted_peak_bytes", match leafPeak.get? k with
+            | some p => Lean.toJson p | none => Lean.Json.null)]
+        let status (s : String) := Lean.Json.mkObj (base ++ [("status", Lean.Json.str s)])
+        if let some addr := proven.get? k then
+          leaves := leaves.push (Lean.Json.mkObj (base ++
+            [("status", Lean.Json.str "proven-kept"), ("proof", Lean.Json.str (toString addr))]))
+        else if !selectedSet.contains k then
+          leaves := leaves.push (status "unchanged")
+        else match leafParts.get? k with
+          | none => leaves := leaves.push (status "unchanged")
+          | some ps =>
+            let ps := sortedParts k ps
+            let anyFailed := ps.any (·.error != "")
+            for p in ps do
+              if p.error != "" then
+                let names := (p.owned.filterMap fun a =>
+                  (ixonEnv.addrToName.get? a).map toString).extract 0 8
+                failures := failures.push (Lean.Json.mkObj ([("id", Lean.toJson k),
+                  ("label", Lean.Json.str p.label), ("reason", Lean.Json.str p.error),
+                  ("blocks", Lean.toJson p.blocks.size), ("consts", Lean.toJson p.owned.size),
+                  ("predicted_peak_bytes", Lean.toJson p.peak),
+                  ("names", Lean.toJson names)]
+                  ++ (match p.blocks[0]? with
+                      | some b => if p.blocks.size == 1 then [("block", Lean.Json.str (toString b))] else []
+                      | none => [])))
+            if anyFailed then
+              leaves := leaves.push (status "failed")
+            else if ps.size == 1 then
+              leaves := leaves.push (status "measured")
+            else
+              let ids := (newIds.get? k).getD #[]
+              let depth := ps.foldl (fun d p => max d ((p.label.splitOn ".").length - 1)) 0
+              let parts := ps.mapIdx fun i p => Lean.Json.mkObj [
+                ("id", match ids[i]? with | some id => Lean.toJson id | none => Lean.Json.null),
+                ("label", Lean.Json.str p.label), ("blocks", Lean.toJson p.blocks.size),
+                ("consts", Lean.toJson p.owned.size),
+                ("predicted_peak_bytes", Lean.toJson p.peak),
+                ("claim", digestJson p.owned)]
+              leaves := leaves.push (Lean.Json.mkObj (base ++
+                [("status", Lean.Json.str "split"), ("depth", Lean.toJson depth),
+                 ("parts", Lean.Json.arr parts)]))
+      -- Consolidation: the leaf count the measured total says would fit the
+      -- budget — arithmetic from measured peaks, never an execution.
+      let consolidation := if maxRamBytes > 0 then
+          let sum := final.foldl (· + ·.2) 0
+          let target := maxRamBytes * 95 / 100
+          Lean.toJson (max 1 ((sum + target - 1) / target))
+        else Lean.Json.null
+      let sourceDigest ← fileDigest manifestPath
+      let outJson ← match outIxes with
+        | some out =>
+          if wroteManifest then do
+            let d ← fileDigest out
+            let n := shards.size + idTable.foldl (fun acc ids => acc + ids.size - 1) 0
+            pure (fileJson out d (some n))
+          else pure Lean.Json.null
+        | none => pure Lean.Json.null
+      let envBytes ← (do
+        try pure (Lean.toJson (← System.FilePath.metadata ixePath).byteSize.toNat)
+        catch _ => pure Lean.Json.null)
+      let report := Lean.Json.mkObj [
+        ("schema", Lean.Json.str "ix-refine/0"),
+        ("revision", Lean.Json.str (← gitRevision)),
+        ("command", Lean.Json.str opts.command),
+        ("env", Lean.Json.mkObj [("path", Lean.Json.str ixePath), ("bytes", envBytes)]),
+        ("source", fileJson manifestPath sourceDigest (some shards.size)),
+        ("out", outJson),
+        ("budget_bytes", Lean.toJson maxRamBytes),
+        ("budget_source", Lean.Json.str opts.budgetSource),
+        ("jobs", Lean.toJson jobs),
+        ("selected", Lean.toJson selected.size),
+        ("executed", Lean.toJson executed),
+        ("waves", Lean.toJson waves),
+        ("consolidation_shards", consolidation),
+        ("leaves", Lean.Json.arr leaves),
+        ("failures", Lean.Json.arr failures)]
+      IO.FS.writeFile reportPath (report.pretty ++ "\n")
+      IO.println s!"[{tag}] report → {reportPath}"
+    -- One env-keyed results row for `ix bench run --backend aiur-sharded-env`:
+    -- the measured window is the wave-0 batch FFI call (env load and
+    -- blob setup are excluded, matching what the benchmark tracks — the
+    -- execution engine, not the loader).
+    if let some (path, key) := json? then
+      let secs := elapsedMs.toFloat / 1000.0
+      let tput := if elapsedMs > 0
+        then totalConsts.toFloat * 1000.0 / elapsedMs.toFloat else 0.0
+      let peakRss ← TracingTexray.peakTreeRssBytes
+      let status := if failed.isEmpty then "ok" else "rejected"
+      Ix.Benchmark.Results.writeRow path key status
+        [ ("constants", Lean.toJson totalConsts)
+        , ("shards", Lean.toJson final.size)
+        , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs)
+        , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput)
+        , ("peak-rss", Lean.toJson peakRss) ]
+    if failed.isEmpty then
+      IO.println s!"All {final.size} shard(s) passed"
+      return 0
+    IO.eprintln s!"{failed.size} of {final.size} shard(s) FAILED:"
+    for f in failed do IO.eprintln s!"  {f}"
+    -- `ix shard refine` still wrote its manifest (failed leaves unchanged):
+    -- exit 2 tells the operator to read the report. Under `--json` a kernel
+    -- rejection is the benchmark's `rejected` exit (the row is already
+    -- written), same contract as `check-rs`.
+    if opts.emitOnFailure then return 2
+    return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1
+
 
 /-- Run the shard operation over EVERY shard — the whole-partition behavior of
     `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1
@@ -768,6 +1420,10 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do
   let names := (p.variableArgsAs! String).toList
   let ixesPath := (p.flag? "ixes").map (·.as! String)
   let shardK := (p.flag? "shard").map (·.as! Nat)
+  let profileOut := (p.flag? "profile").map (·.as! String)
+  if profileOut.isSome && interpSource then
+    IO.eprintln "error: --profile is not available with --interp source"
+    return 1
   -- a single targeted constant, a `--claim`, or a single shard each print
   -- per-circuit stats; whole-env / whole-partition iteration suppresses them.
   let printStats := names.length == 1 || claimHex.isSome || (ixesPath.isSome && shardK.isSome)
@@ -800,9 +1456,14 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do
       let compiled ← match toplevel.compile with
         | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1
         | .ok c => pure c
+      -- Per-name / per-claim targets carry no addr→name index here (the
+      -- ixon env loads later, inside `forEachClaim`), so `--profile`
+      -- lines dump address-only on this path; the shard-native paths
+      -- below join names via `ixonEnv.addrToName`.
+      let profile? := profileOut.map ((·, fun _ => none))
       let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target)
           (label : String) : IO UInt32 :=
-        runCompiled compiled printStats statsOut useBytecode envHandle? target label
+        runCompiled compiled printStats statsOut profile? useBytecode envHandle? target label
       pure go
   match ixePath, ixesPath, shardK with
   | some ixe, some manifest, some k =>
@@ -813,7 +1474,7 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do
       let compiled ← match toplevel.compile with
         | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1
         | .ok c => pure c
-      return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode)
+      return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut profileOut useBytecode)
   | some ixe, some manifest, none   =>
     if interpSource then
       return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat))
@@ -824,8 +1485,31 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do
         | .ok c => pure c
       let json? := (p.flag? "json").map fun f =>
         (f.as! String, ((p.flag? "json-name").map (·.as! String)).getD "env")
+      -- `--ram-budget G` gates the audit; `--ram-budget 0` detects this
+      -- machine's budget (85% of MemAvailable, fail closed); omitted = the
+      -- plain batch check, no gate.
+      let (maxRamBytes, budgetSource) ← match (p.flag? "ram-budget").map (·.as! Nat) with
+        | none => pure (0, "none")
+        | some g =>
+          if g > 0 then pure (g * gibBytes, "flag")
+          else
+            let b ← Aiur.detectedRamBudgetBytes
+            if b == 0 then
+              IO.eprintln "--ram-budget 0: cannot detect MemAvailable (/proc/meminfo unreadable)"
+              return 1
+            IO.println s!"[split-audit] budget {toGib b} GiB (detected: 85% of MemAvailable)"
+            pure (b, "detected")
+      let selection? ← match (p.flag? "shards").map (·.as! String) with
+        | none => pure none
+        | some s => match parseShardSelection s with
+          | .error e => IO.eprintln s!"error: {e}"; return 1
+          | .ok ids => pure (some ids)
       return (← runShardBatchNative manifest ixe
-        ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode json?)
+        ((p.flag? "jobs").map (·.as! Nat)) compiled useBytecode profileOut json?
+        maxRamBytes ((p.flag? "out-ixes").map (·.as! String))
+        { selection := selection?, report := (p.flag? "report").map (·.as! String),
+          command := s!"ix check --ixe {ixe} --ixes {manifest}", budgetSource })
+
   | _, _, _ =>
     -- `--jobs N` (N ≠ 1) with an `--ixe` env and no `--claim` takes the
     -- parallel batch path: one FFI call, rayon over the target list,
@@ -855,11 +1539,16 @@ def checkCmd : Cli.Cmd := `[Cli|
     "ixe"       : String;   "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env."
     "claim"     : String;   "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)."
     "stats-out" : String;   "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)."
+    "profile"   : String;   "Append per-constant virtual-gas costs to this file: one `<addr_hex> <vspan> <mult> [name]` line per `check_const` query, read from the execution's QueryRecordHandle (names joined on the shard paths, where the env's addr→name index is loaded). The vspan is the constant's standalone check cost within its shard — memo hits replay the callee's recorded span. Order-independent within a partition, but spans of constants whose dependency cone crosses an assumption boundary shift between partitions (foreign callees are assumed, not replayed); schedule off a profile measured under the partition being scheduled. Not available with `--interp source`."
     "ixes"      : String;   "Path to a `.ixes` shard manifest (with --ixe). With --shard K: check the constants owned by shard K (ingress their closure, skip the frontier). Without --shard: check every shard of the partition concurrently, after a coverage check."
     "shard"     : Nat;      "0-based shard index K (with --ixe + --ixes): check the constants owned by shard K of the manifest's partition."
     "jobs"      : Nat;      "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures."
     "json"      : String;   "With --ixes (no --shard): append one env-keyed results row (see Ix.Benchmark.Results) for the batch to this file — check-time, throughput, peak-rss, constants, shards. Used by `ix bench run --backend aiur-sharded-env`."
     "json-name" : String;   "Row key for the --json row (default: `env`)."
+    "ram-budget" : Nat;     "The destination prove box's per-shard RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits — the exec-only split audit. Under-filled partitions get a printed suggestion (the shard count the measured total says would fit), never an extra execution: re-shard with --shards N and let the next run's mandatory executions verify it inline. Same unit and model as `ix prove --max-ram`, but no auto-detection: the budget describes the prove box the partition is destined for, not the machine running the check. Omit for a plain check."
+    "out-ixes"  : String;   "With --ram-budget: write the partition the wave loop actually validated as a refinement of the source manifest — untouched leaves keep their records, ids and aggregation-tree positions, each split leaf becomes a subtree over its parts. Skipped if any shard failed. The manifest the next run of this env should start from."
+    "shards"    : String;   "With --ixes (no --shard): restrict the batch to these leaves — `K`, `a-b`, or a comma list of those. Every other leaf is left untouched (and, with --out-ixes, carried over unchanged)."
+    "report"    : String;   "With --ixes (no --shard): write the provisional JSON audit report (`ix-refine/0`: per-leaf status, predicted peaks, claim digests, split parts with their new ids, failures) to this path."
 
   ARGS:
     ...names : String; "Fully-qualified Lean.Name(s) to check. With none, iterate every named constant in the env (sorted)."
diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean
index f958c4bee..79b595c31 100644
--- a/Ix/Cli/CodegenCmd.lean
+++ b/Ix/Cli/CodegenCmd.lean
@@ -1,10 +1,12 @@
 /-
-  `ix codegen`: write the IxVM kernel and the MultiStark recursive
-  verifier as Rust source files via the Bytecode → Rust codegen pass.
+  `ix codegen`: write the IxVM kernel, the MultiStark recursive
+  verifier, and the ixAggr aggregation system as Rust source files via
+  the Bytecode → Rust codegen pass.
 
   Output paths are fixed at compile time:
   - `crates/ixvm-codegen/src/aiur_ixvm.rs` (the IxVM kernel)
   - `crates/ixvm-codegen/src/aiur_multi_stark.rs` (the recursive verifier)
+  - `crates/ixvm-codegen/src/aiur_ix_aggr.rs` (the heterogeneous aggregator)
   The generated files are the single destinations; no flag overrides.
 
   Output per target: a Rust module body containing one `fn aiur_fn_N(...)`
@@ -26,6 +28,7 @@
 -/
 module
 public import Cli
+public import Ix.Aggr
 public import Ix.Aiur.Compiler
 public import Ix.Aiur.Stages.Codegen
 public import Ix.IxVM
@@ -53,7 +56,12 @@ def targets : List Target := [
   { label := "ixvm", source := IxVM.ixVM,
     outPath := "crates/ixvm-codegen/src/aiur_ixvm.rs" },
   { label := "multi-stark", source := MultiStark.multiStark,
-    outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" }
+    outPath := "crates/ixvm-codegen/src/aiur_multi_stark.rs" },
+  -- `ix aggregate` proving/verification must select the SAME toplevel for its
+  -- function-index table (`Aggr.ixAggr`), or `ix_aggr` lookups resolve
+  -- against a different function set than the generated code.
+  { label := "ix-aggr", source := Aggr.ixAggr,
+    outPath := "crates/ixvm-codegen/src/aiur_ix_aggr.rs" }
 ]
 
 /-- Emit one target. In `--check` mode, compares against the on-disk file
@@ -104,10 +112,10 @@ end Ix.Cli.CodegenCmd
 open Ix.Cli.CodegenCmd in
 def codegenCmd : Cli.Cmd := `[Cli|
   "codegen" VIA runCodegenCmd;
-  "Compile the IxVM Aiur kernel and the MultiStark recursive verifier to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ixvm-codegen/src/aiur_ixvm.rs` and `crates/ixvm-codegen/src/aiur_multi_stark.rs` (fixed paths, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces."
+  "Compile the IxVM kernel, MultiStark verifier, and single-entrypoint ixAggr system to Rust via the Bytecode → Rust codegen pass (fixed output paths, no override). PARITY UNVERIFIED — run their generated/interpreter fixture checks before trusting any witness."
 
   FLAGS:
-    "check"; "CI mode: compare the emitted source against the on-disk files at `crates/ixvm-codegen/src/aiur_ixvm.rs` and `crates/ixvm-codegen/src/aiur_multi_stark.rs` and exit 0 if identical, 1 otherwise. Does not modify the files."
+    "check"; "CI mode: compare all three emitted sources (`aiur_ixvm.rs`, `aiur_multi_stark.rs`, `aiur_ix_aggr.rs`) against disk and exit 0 if identical, 1 otherwise. Does not modify files."
 ]
 
 end
diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean
index f5802c09e..e527ad14e 100644
--- a/Ix/Cli/ProveCmd.lean
+++ b/Ix/Cli/ProveCmd.lean
@@ -30,6 +30,7 @@ public import Ix.Aiur.Compiler
 public import Ix.Aiur.Protocol
 public import Ix.Claim
 public import Ix.Cli.CheckCmd
+public import Ix.Cli.ShardProofIndex
 public import Ix.Common
 public import Ix.IxVM
 public import Ix.IxVM.Toplevel
@@ -86,7 +87,13 @@ def proveOne (aiurSystem : Aiur.AiurSystem)
       | .error e =>
         IO.eprintln s!"{label}: shardProveWithEnv error: {e}"
         return 1
-      | .ok (_claimBytes, proof, _outIO) => pure proof
+      | .ok r => match r.proof with
+        | some proof => pure proof
+        | none =>
+          IO.eprintln s!"{label}: projected prover peak {r.peakBytes} bytes \
+            exceeds the budget; this target is not a manifest shard, so it \
+            cannot be split — raise --max-ram"
+          return 1
     | .leanW witness, _ =>
       match aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer with
       | .error e =>
@@ -101,47 +108,167 @@ def proveOne (aiurSystem : Aiur.AiurSystem)
   IO.println (toString proofAddr)
   return 0
 
-/-- Per-shard prove via the end-to-end Rust path
-    (`shardProveIxVM`): witness build, `execute_ixvm`, and STARK
-    prove run in one FFI trip with the parallel Rust witness
-    builder. -/
-def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle)
-    (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat)
-    (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel)
-    (_printStats : Bool) : IO UInt32 := do
-  match shards[shardK]? with
-  | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1
-  | some blocks => do
-    let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks
-    let mut blob := ByteArray.empty
-    for a in owned do
-      blob := blob ++ a.hash
-    let label := s!"shard {shardK}"
-    IO.println s!"Proving {label}"
-    (← IO.getStdout).flush
-    let funIdx := compiled.getFuncIdx `verify_claim |>.get!
-    match aiurSystem.shardProveWithEnv funIdx envHandle blob with
-    | .error e =>
-      IO.eprintln s!"{label}: shardProveWithEnv error: {e}"
-      return 1
-    | .ok (claimBytes, proof, _outIO) =>
+/-- Prove the constants owned by `blocks` as ONE shard, cutting it into
+    the peak model's suggested part count whenever the executed record's
+    projected prover peak exceeds the budget, and recursing on any part
+    that still misses.
+
+    Cuts are contiguous equal-block-count runs: rows are what the RAM
+    model responds to, and equal-cumulative-vspan cuts measured worse
+    on every axis (parts, depth, executions) across a synthetic
+    fixture, init, and lean — vspan tracks time, not rows.
+
+    A shard is only a plan, never part of a statement: its claim is
+    `checkEnv(ownedRoot, asmRoot)`, a pure function of `(env, owned)`
+    with the frontier recomputed from the owned set. So cutting `blocks`
+    yields claims exactly as valid as the parent's — each part's grown
+    frontier is discharged by its siblings — and the cut costs only the
+    parent's execution, the cheap half of the run. Splitting on BLOCKS
+    rather than constants is what keeps mutual-recursion groups intact,
+    since every constant maps to exactly one block.
+
+    The suggested count is optimistic — parts re-execute dependencies
+    shared across the cut, and equal block counts are not equal row
+    counts — so each part is gated on its own executed record and
+    re-cut if it misses. That bias is deliberate: an under-cut costs
+    one cheap re-execution, an over-cut pays the per-proof floor on
+    every extra part for the life of the partition.
+
+    Returns the parts actually proven, in proof order, each with its
+    measured projected prover peak: the parent's own when it fit,
+    otherwise its descendants'. That is the partition the run really
+    produced — what the corrected manifest describes, peaks included. -/
+partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle)
+    (ixonEnv : Ixon.Env) (aiurSystem : Aiur.AiurSystem)
+    (funIdx : Aiur.Bytecode.FunIdx) (maxRamBytes : Nat)
+    (execOnly : Bool) (compiled : Aiur.CompiledToplevel)
+    (indexDir? : Option System.FilePath) (skipProven : Bool) (label : String)
+    (blocks owned : Array Address) :
+    IO (Except String (Array (Array Address × Nat))) := do
+  -- Claim-addressed resume: a leaf's identity is its claim digest, so a
+  -- verified proof of exactly this claim in the shard-proof index is the
+  -- proof this run would produce — reuse it without executing anything.
+  if skipProven then
+    if let some dir := indexDir? then
+      if let .ok (claim, _) := IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned then
+        if let some addr ← Ix.Cli.ShardProofIndex.verifiedProof aiurSystem compiled dir claim then
+          let digest := Address.blake3 (Ix.Claim.ser claim)
+          IO.println s!"[{label}] verified proof of claim {digest} in the \
+            shard-proof index — reused"
+          IO.println s!"claim {digest}"
+          IO.println (toString addr)
+          return .ok #[(blocks, 0)]
+  let mut blob := ByteArray.empty
+  for a in owned do
+    blob := blob ++ a.hash
+  IO.println s!"Proving {label} ({blocks.size} blocks, {owned.size} consts)"
+  (← IO.getStdout).flush
+  match aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes
+      execOnly with
+  | .error e => return .error s!"{label}: shardProveWithEnv error: {e}"
+  | .ok { claimBytes, proof, peakBytes, suggestedParts } =>
+    let gib := toGib peakBytes
+    match proof with
+    | none =>
+      -- The peak fit but nothing proved: reachable only in exec-only
+      -- mode (a budgeted prove either proves or suggests ≥ 2 parts).
+      if suggestedParts <= 1 then
+        IO.println s!"[{label}] prover peak {gib} GiB (exec-only)"
+        return .ok #[(blocks, peakBytes)]
+      -- A single block is the atom the kernel checks together; there is
+      -- no smaller shard to fall back to.
+      if blocks.size <= 1 then
+        return .error s!"{label}: projected prover peak {gib} GiB exceeds \
+          the budget and the shard is a single block — raise --max-ram"
+      let cut := Ix.Cli.CheckCmd.cutBlocks blocks suggestedParts
+      IO.println s!"[{label}] peak {gib} GiB over budget — cutting \
+        {blocks.size} blocks into {cut.size} parts"
+      let cutOwned := Ix.Cli.CheckCmd.partitionOwned ixonEnv owned cut
+      let mut proven : Array (Array Address × Nat) := #[]
+      for (i, part, po) in (cut.zip cutOwned).mapIdx
+          (fun i (part, po) => (i, part, po)) do
+        match ← proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx
+            maxRamBytes execOnly compiled indexDir? skipProven
+            s!"{label}.{i}" part po with
+        | .error e => return .error e
+        | .ok parts => proven := proven ++ parts
+      return .ok proven
+    | some proof =>
+      IO.println s!"[{label}] prover peak {gib} GiB"
       -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize
       -- back to `Ix.Claim` to persist alongside the proof. Avoids
       -- recomputing the closure walk + canonical AssumptionTree Lean-side.
       match Ixon.runGet Ix.Claim.get claimBytes with
-      | .error e =>
-        IO.eprintln s!"{label}: Claim wire-decode failed: {e}"
-        return 1
+      | .error e => return .error s!"{label}: Claim wire-decode failed: {e}"
       | .ok claim => do
         let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim))
         let wrapper : Ixon.Proof := { claim, proof := proof.toBytes }
         let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper))
+        -- The claim digest is the leaf's durable identity; print it next to
+        -- the address so a runner can key its progress on it, and index the
+        -- proof under it for `--skip-proven` and `ix shard refine`.
+        let digest := Address.blake3 (Ix.Claim.ser claim)
+        IO.println s!"claim {digest}"
         IO.println (toString proofAddr)
-        let _ := manifestPath  -- kept for parity with previous signature
-        return 0
+        if let some dir := indexDir? then
+          Ix.Cli.ShardProofIndex.writeAddress dir digest proofAddr
+        return .ok #[(blocks, peakBytes)]
+
+/-- Prove shard `shardK` of the partition, splitting it as needed.
+    Returns the block sets actually proven for that shard. -/
+def runShardProveNative (envHandle : Aiur.EnvHandle) (ixonEnv : Ixon.Env)
+    (shards ownedPerShard : Array (Array Address)) (shardK : Nat)
+    (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel)
+    (maxRamBytes : Nat) (execOnly : Bool)
+    (indexDir? : Option System.FilePath) (skipProven : Bool) :
+    IO (Except String (Array (Array Address × Nat))) := do
+  match shards[shardK]?, ownedPerShard[shardK]? with
+  | some blocks, some owned =>
+    let funIdx := compiled.getFuncIdx `verify_claim |>.get!
+    proveBlocksWithinBudget envHandle ixonEnv aiurSystem funIdx maxRamBytes
+      execOnly compiled indexDir? skipProven s!"shard {shardK}" blocks owned
+  | _, _ => return .error s!"shard {shardK} out of range (0..{shards.size})"
+
+/-- Report the partition a prove run actually produced against the one
+    its manifest planned. They differ exactly when a shard was split. -/
+def reportPartition (proven : Array (Array Address × Nat)) (planned : Nat) : IO Unit := do
+  if proven.size == planned then
+    IO.println s!"[prove] {proven.size} shard(s) proven, partition unchanged"
+  else
+    IO.println s!"[prove] {proven.size} shard(s) proven from {planned} planned \
+      ({proven.size - planned} from splits) — re-shard with this partition to \
+      skip the splits next run"
 
 def runProveCmd (p : Cli.Parsed) : IO UInt32 := do
+  -- Streamed `[texray] <span>: <dur> ── RAM Δ/peak` lines on stderr as
+  -- each `aiur/` / `stark/` span closes: the per-phase wall + RSS
+  -- breakdown (execute vs witness vs STARK) of every prove in the run.
+  if p.hasFlag "texray" then TracingTexray.init {}
   let keepGoing := p.hasFlag "keep-going"
+  -- Same units as `ix shard --max-ram`: the per-shard prover budget the
+  -- partition was sized against, re-checked here against each shard's
+  -- measured peak. 0 = detect (85% of `MemAvailable`, the check batch's
+  -- gate policy — see `shardProveWithEnv`).
+  let maxRamBytes :=
+    ((p.flag? "max-ram").map (·.as! Nat)).getD 0 * gibBytes
+  let execOnly := p.hasFlag "exec-only"
+  let outIxes := (p.flag? "out-ixes").map (·.as! String)
+  -- The shard-proof index: written for every proof this run persists,
+  -- consulted before executing a leaf under `--skip-proven`.
+  let skipProven := p.hasFlag "skip-proven"
+  let indexDir? ← if p.hasFlag "no-index" then pure none
+    else some <$> Ix.Cli.ShardProofIndex.indexDir
+  -- Both `--ixes` branches end the same way: the partition the run
+  -- actually proved, written as a refinement of the manifest it started
+  -- from — the one the next run of this env should start from.
+  let emitRefined (envHandle : Aiur.EnvHandle) (sourcePath : String)
+      (numShards : Nat) (runs : Array (Nat × Array (Array Address × Nat)))
+      (failures : Nat) : IO Unit := do
+    if let some out := outIxes then
+      let (refinements, measured) :=
+        Ix.Cli.CheckCmd.refinementsOfRuns numShards runs
+      let _ ← Ix.Cli.CheckCmd.emitRefinedManifest "prove" envHandle
+        sourcePath out refinements measured failures
   let ixePath : Option String := (p.flag? "ixe").map (·.as! String)
   let claimHex : Option String := (p.flag? "claim").map (·.as! String)
   let names := (p.variableArgsAs! String).toList
@@ -163,7 +290,19 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do
       let envHandle ← match Aiur.EnvHandle.fromIxe ixe with
         | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1
         | .ok h => pure h
-      runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false
+      match ← runShardProveNative envHandle ixonEnv shards
+          (Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards) k aiurSystem
+          compiled maxRamBytes execOnly indexDir? skipProven with
+      | .error e => IO.eprintln e; return 1
+      | .ok parts =>
+        -- A single-shard run plans exactly one shard, not the whole
+        -- partition.
+        reportPartition parts 1
+        -- The refined whole partition: the source manifest with shard k
+        -- replaced by the parts this run actually proved; every other
+        -- leaf is carried over untouched (this run never executed them).
+        emitRefined envHandle manifest shards.size #[(k, parts)] 0
+        return 0
   | some ixe, some manifest, none =>
     -- IxVM-native all-shards prove. Same envHandle reused across
     -- every shard.
@@ -173,12 +312,49 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do
       let envHandle ← match Aiur.EnvHandle.fromIxe ixe with
         | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1
         | .ok h => pure h
-      let mut rc : UInt32 := 0
-      for k in [0 : shards.size] do
-        if (← runShardProveNative manifest envHandle ixonEnv shards k
-              aiurSystem compiled false) != 0 then
-          rc := 1
-      pure rc
+      -- Accumulate the partition the run actually produced. Splits stay
+      -- in this process, so the manifest describing them is written
+      -- once at the end rather than rewritten per split. Ownership is
+      -- assigned in ONE env pass here; splits inherit it.
+      let ownedPer := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards
+      -- `--shards SEL` restricts the run to some leaves (one env load for
+      -- all of them); every other leaf is carried over unchanged.
+      let selected : Array Nat ← match (p.flag? "shards").map (·.as! String) with
+        | none => pure (Array.range shards.size)
+        | some s => match Ix.Cli.CheckCmd.parseShardSelection s with
+          | .error e => IO.eprintln s!"error: {e}"; return 1
+          | .ok ids =>
+            if let some k := ids.find? (· ≥ shards.size) then
+              IO.eprintln s!"--shards: shard {k} out of range ({shards.size} shards)"
+              return 1
+            pure ids
+      let mut runs : Array (Nat × Array (Array Address × Nat)) := #[]
+      let mut proven : Array (Array Address × Nat) := #[]
+      let mut failed : Array String := #[]
+      for k in selected do
+        match ← runShardProveNative envHandle ixonEnv shards ownedPer k
+            aiurSystem compiled maxRamBytes execOnly indexDir? skipProven with
+        | .error e => IO.eprintln e; failed := failed.push e
+        | .ok parts => runs := runs.push (k, parts); proven := proven ++ parts
+      if failed.isEmpty then
+        reportPartition proven selected.size
+        -- Consolidation is arithmetic from the peaks this run already
+        -- measured, never an extra execution: the measured sum only
+        -- shrinks as shards get coarser, so the count is a safe
+        -- under-count, verified inline by the next run's own gate.
+        if maxRamBytes > 0 then
+          let sum := proven.foldl (· + ·.2) 0
+          let n1 := max 1 ((sum + maxRamBytes * 95 / 100 - 1)
+            / (maxRamBytes * 95 / 100))
+          if n1 < proven.size then
+            IO.println s!"[prove] measured total {toGib sum} GiB — {n1} \
+              shard(s) would fit the budget: re-shard with --shards {n1}"
+      else
+        IO.eprintln s!"[prove] {failed.size} of {shards.size} shard(s) FAILED:"
+        for e in failed do
+          IO.eprintln s!"  {e}"
+      emitRefined envHandle manifest shards.size runs failed.size
+      return if failed.isEmpty then 0 else 1
   | _, _, _ =>
     Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne
 
@@ -191,10 +367,17 @@ def proveCmd : Cli.Cmd := `[Cli|
 
   FLAGS:
     "keep-going";       "Continue past failures and report them at the end instead of halting on the first."
+    "texray";           "Stream per-phase `[texray]` timing/RSS lines (execute, witness, STARK stages) to stderr as each span closes."
     "ixe"   : String;   "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env."
     "claim" : String;   "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, proves the persisted claim against the `--ixe` env (single proof, skips per-const iteration)."
     "ixes"  : String;   "Path to a `.ixes` shard manifest (with --ixe). With --shard K: prove shard K. Without --shard: prove every shard in the partition."
     "shard" : Nat;      "0-based shard index K (with --ixes and --ixe): prove that one shard's CheckEnv claim."
+    "shards" : String;  "With --ixes and no --shard: prove only these leaves — `K`, `a-b`, or a comma list of those — in one process (one env load); every other leaf is carried over unchanged by --out-ixes."
+    "out-ixes" : String; "Write the partition this run actually proved — splits included — as a `.ixes` manifest to this path: the manifest `ix verify --ixes` checks these proofs against, and the one the next run of this env should start from. Skipped if any shard failed."
+    "exec-only";        "Execute each shard and measure its projected prover peak, splitting over-budget shards as usual, but never start a STARK. The cheap way to audit a partition's split behavior at scale."
+    "skip-proven";      "With --ixes: before executing a leaf, look its claim up in the shard-proof index (`~/.ix/cache/shard-proofs/<claim-digest>`); a recorded proof that decodes, bundles exactly that claim and verifies natively is reused — its address printed, nothing executed — instead of proving again. How a partially proved partition resumes after a refinement."
+    "no-index";         "Neither read nor write the shard-proof index (every persisted proof is normally recorded there under its claim digest)."
+    "max-ram" : Nat;    "Per-shard prover-RAM budget, GiB — normally the same value the partition was sized with (`ix shard --max-ram`). Each shard is executed, its projected prover peak measured on the resulting record, and the proof attempted only if it fits; an over-budget shard is cut into the part count the peak model projects will fit, and each part re-gated, instead of being taken into the FFT phases that would exhaust the box. Omit to detect: 85% of the machine's available RAM."
 
   ARGS:
     ...names : String; "Fully-qualified Lean.Name(s) to prove. With none, iterate every named constant in the env (sorted)."
diff --git a/Ix/Cli/RefineCmd.lean b/Ix/Cli/RefineCmd.lean
new file mode 100644
index 000000000..6af3e3934
--- /dev/null
+++ b/Ix/Cli/RefineCmd.lean
@@ -0,0 +1,168 @@
+/-
+  `ix shard refine <path.ixe> --ixes M.ixes --out M2.ixes [--shards SEL]
+  [--max-ram G] [--jobs N] [--report R.json] [--no-index]`: the local
+  refinement of an existing partition. Every selected leaf (default: all) is
+  executed and its analytic prover peak measured; a leaf over the budget is
+  cut into the part count the peak model projects will fit and the parts
+  re-executed, wave by wave, until everything fits or is a single block. The
+  result is written as a refinement of the source manifest: untouched leaves
+  keep their records, ids and tree positions, and each split leaf becomes a
+  balanced subtree over its parts (part 0 keeps the leaf's id, later parts
+  take fresh ids after the last existing one). A leaf whose claim already
+  has a verified proof in the shard-proof index is never split, whatever its
+  peak: refinement must never orphan a proof. Failures leave their leaf
+  unchanged, are listed in the report, and make the exit code 2.
+-/
+module
+public import Cli
+public import Ix.Common
+public import Ix.Aiur.Protocol
+public import Ix.Cli.CheckCmd
+public import Ix.Cli.ShardProofIndex
+public import Ix.IxVM
+public import Ix.IxVM.Toplevel
+public import Ix.IxVM.ClaimHarness
+
+public section
+
+namespace Ix.Cli.RefineCmd
+
+/-- The budget the refinement gates on: `--max-ram G` (GiB), or the machine's
+    detected 85 % of `MemAvailable` when omitted or `0`. `none` when nothing
+    can be detected — the caller fails closed. -/
+def resolveBudget (maxRam? : Option Nat) : IO (Option (Nat × String)) := do
+  match maxRam? with
+  | some g => if g > 0 then return some (g * gibBytes, "flag") else detect
+  | none => detect
+where
+  detect : IO (Option (Nat × String)) := do
+    let b ← Aiur.detectedRamBudgetBytes
+    if b == 0 then return none
+    IO.println s!"[refine] budget {toGib b} GiB (detected: 85% of MemAvailable)"
+    pure (some (b, "detected"))
+
+def runShardRefineCmd (p : Cli.Parsed) : IO UInt32 := do
+  let some pathArg := p.positionalArg? "path"
+    | p.printError "error: must specify <path> to a .ixe file"; return 1
+  let ixePath := pathArg.as! String
+  let some manifest := (p.flag? "ixes").map (·.as! String)
+    | p.printError "error: --ixes <manifest.ixes> is required"; return 1
+  let some out := (p.flag? "out").map (·.as! String)
+    | p.printError "error: --out <refined.ixes> is required"; return 1
+  let selection? ← match (p.flag? "shards").map (·.as! String) with
+    | none => pure none
+    | some s => match Ix.Cli.CheckCmd.parseShardSelection s with
+      | .error e => p.printError s!"error: {e}"; return 1
+      | .ok ids => pure (some ids)
+  let some (maxRamBytes, budgetSource) ← resolveBudget ((p.flag? "max-ram").map (·.as! Nat))
+    | p.printError "error: cannot detect MemAvailable (/proc/meminfo unreadable); pass --max-ram G"
+      return 1
+  let jobs? := (p.flag? "jobs").map (·.as! Nat)
+  let report? := (p.flag? "report").map (·.as! String)
+  let toplevel ← match IxVM.ixVM with
+    | .error e => IO.eprintln s!"toplevel merging failed: {e}"; return 1
+    | .ok t => pure t
+  let compiled ← match toplevel.compile with
+    | .error e => IO.eprintln s!"compilation failed: {e}"; return 1
+    | .ok c => pure c
+  -- The proven-leaf guard: a selected leaf whose claim already has a
+  -- verified proof in the index is kept exactly as it is.
+  let guard? ← if p.hasFlag "no-index" then pure none else do
+    let aiurSystem := Aiur.AiurSystem.build compiled.bytecode
+      Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
+    let dir ← Ix.Cli.ShardProofIndex.indexDir
+    pure (some fun (ixonEnv : Ixon.Env) (_ : Array (Array Address))
+        (ownedAll : Array (Array Address)) (selected : Array Nat) => do
+      let mut kept : Std.HashMap Nat Address := {}
+      for k in selected do
+        let some owned := ownedAll[k]? | continue
+        match IxVM.ClaimHarness.shardCheckEnvClaimTrees ixonEnv owned with
+        | .error _ => continue
+        | .ok (claim, _) =>
+          if let some addr ← Ix.Cli.ShardProofIndex.verifiedProof aiurSystem compiled dir claim then
+            IO.println s!"[refine] shard {k}: verified proof {addr} in the index — kept"
+            kept := kept.insert k addr
+      pure kept)
+  let command := String.intercalate " " (#["ix shard refine", ixePath, "--ixes", manifest, "--out", out]
+    ++ (match (p.flag? "shards").map (·.as! String) with | some s => #["--shards", s] | none => #[])
+    ++ (match (p.flag? "max-ram").map (·.as! Nat) with | some g => #["--max-ram", toString g] | none => #[])
+    ++ (match jobs? with | some j => #["--jobs", toString j] | none => #[])
+    ++ (match report? with | some r => #["--report", r] | none => #[])
+    ++ (if p.hasFlag "no-index" then #["--no-index"] else #[])).toList
+  Ix.Cli.CheckCmd.runShardBatchNative manifest ixePath jobs? compiled false none none
+    maxRamBytes (some out)
+    { selection := selection?, provenGuard := guard?, report := report?,
+      emitOnFailure := true, command, budgetSource }
+
+end Ix.Cli.RefineCmd
+
+open Ix.Cli.RefineCmd in
+def shardRefineCmd : Cli.Cmd := `[Cli|
+  "refine" VIA runShardRefineCmd;
+  "Refine an existing `.ixes` partition against a prover-RAM budget: execute the selected leaves, cut every over-budget one into parts the peak model says will fit (recursively), and write the result as a refinement of the source manifest — untouched leaves keep their records, ids and aggregation-tree positions; a leaf that already has a verified proof in the shard-proof index is never split"
+
+  FLAGS:
+    ixes       : String; "The source `.ixes` manifest (required)."
+    out        : String; "Where to write the refined `.ixes` manifest (required). Written even when some leaves failed (they stay unchanged; exit 2)."
+    shards     : String; "Leaves to audit: `K`, `a-b`, or a comma list of those. Default: every leaf. Unselected leaves are carried over unchanged."
+    "max-ram"  : Nat;    "Per-shard prover-RAM budget, GiB, in `ix prove --max-ram` units. Omitted or 0: detect 85% of this machine's MemAvailable (an error if that cannot be read)."
+    jobs       : Nat;    "Rayon threads for the execution batch (default: all cores; admission is bounded by the RAM gate, not by thread count)."
+    report     : String; "Write the provisional JSON audit report (`ix-refine/0`: per-leaf status, predicted peaks, claim digests, split parts with their new ids, failures) to this path."
+    "no-index";          "Do not consult `~/.ix/cache/shard-proofs`: split over-budget leaves even when a verified proof of their claim exists (testing only)."
+
+  ARGS:
+    path : String; "Path to the serialized `.ixe` environment the manifest partitions."
+]
+
+namespace Ix.Cli.RefineCmd
+
+/-- `ix shard claims <path.ixe> --ixes M.ixes [--report R.json]`: every leaf's
+    `CheckEnv` claim digest, one `id digest blocks consts` line per leaf, from
+    one env pass. The digest is a leaf's identity: what `ix prove` persists,
+    what `ix verify --shard K` reconstructs, and what `ix aggregate` matches
+    proofs on — never its manifest index. -/
+def runShardClaimsCmd (p : Cli.Parsed) : IO UInt32 := do
+  let some pathArg := p.positionalArg? "path"
+    | p.printError "error: must specify <path> to a .ixe file"; return 1
+  let ixePath := pathArg.as! String
+  let some manifest := (p.flag? "ixes").map (·.as! String)
+    | p.printError "error: --ixes <manifest.ixes> is required"; return 1
+  match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixePath) with
+  | .error e => IO.eprintln e; return 1
+  | .ok (ixonEnv, shards) =>
+    let ownedAll := Ix.Cli.CheckCmd.ownedConstsPer ixonEnv shards
+    let mut rows : Array Lean.Json := #[]
+    let mut rc : UInt32 := 0
+    for k in [0:shards.size] do
+      let blocks := (shards[k]?).getD #[]
+      let owned := (ownedAll[k]?).getD #[]
+      match Ix.Cli.CheckCmd.claimDigestOfOwned ixonEnv owned with
+      | .error e => IO.eprintln s!"shard {k}: {e}"; rc := 1
+      | .ok d =>
+        IO.println s!"{k} {d} {blocks.size} {owned.size}"
+        rows := rows.push (Lean.Json.mkObj [("id", Lean.toJson k),
+          ("claim", Lean.Json.str (toString d)), ("blocks", Lean.toJson blocks.size),
+          ("consts", Lean.toJson owned.size)])
+    if let some out := (p.flag? "report").map (·.as! String) then
+      let report := Lean.Json.mkObj [("schema", Lean.Json.str "ix-refine/0"),
+        ("source", Lean.Json.mkObj [("path", Lean.Json.str manifest),
+          ("shards", Lean.toJson shards.size)]),
+        ("leaves", Lean.Json.arr rows)]
+      IO.FS.writeFile out (report.pretty ++ "\n")
+      IO.println s!"[claims] report → {out}"
+    return rc
+
+end Ix.Cli.RefineCmd
+
+open Ix.Cli.RefineCmd in
+def shardClaimsCmd : Cli.Cmd := `[Cli|
+  "claims" VIA runShardClaimsCmd;
+  "Print every leaf's CheckEnv claim digest of a `.ixes` partition (`id digest blocks consts`, one line per leaf) in one env pass — the identities a claim-keyed runner tracks instead of manifest indices"
+
+  FLAGS:
+    ixes   : String; "The `.ixes` manifest (required)."
+    report : String; "Also write the rows as a provisional JSON report (`ix-refine/0`) to this path."
+
+  ARGS:
+    path : String; "Path to the `.ixe` environment the manifest partitions."
+]
diff --git a/Ix/Cli/ShardCmd.lean b/Ix/Cli/ShardCmd.lean
index e2f0e6d29..04b6854d8 100644
--- a/Ix/Cli/ShardCmd.lean
+++ b/Ix/Cli/ShardCmd.lean
@@ -8,10 +8,12 @@
     static walk-edge nets (the relation that generates each shard's thin
     frontier, i.e. its real ingress), then a global rebalance post-pass
     toward equal predicted Aiur FFT cost (fitted model — constants and
-    provenance in `ix_kernel::shard::STATIC_OWNED_PER_BYTE`). Requires
-    `--shards N`. Measured against the profiled strategy on the 8-shard
-    Init / 24-shard Std harnesses: mean shard FFT −30%, max shard −44/−51%,
-    stddev 17.7%→7.1% / 30.6%→8.9%.
+    provenance in `ix_kernel::shard::STATIC_OWNED_PER_BYTE`). `--shards N`
+    fixes the count; `--max-ram G` seeds it from the same static block-shape
+    score, mildly superlinear in both library scale and inverse RAM budget.
+    Measured against the profiled strategy on the 8-shard Init / 24-shard Std
+    harnesses: mean shard FFT −30%, max shard −44/−51%, stddev 17.7%→7.1% /
+    30.6%→8.9%.
   - **Profiled (`--profile <path.ixprof>`)**: the original pipeline over an
     `ix profile` run, unchanged. Modes (precedence in `runShardCmd`):
     default / `--max-ram G` / `--max-cycles C` **bin-pack to a per-shard
@@ -31,8 +33,10 @@
 -/
 module
 public import Cli
+public import Ix.Common
 public import Ix.KernelCheck
 public import Ix.Cli.ConstsFile
+public import Ix.Cli.RefineCmd
 
 public section
 
@@ -143,40 +147,33 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do
   | none =>
     -- STATIC strategy (no out-of-circuit profiling): byte-balanced min-cut
     -- over the env's walk-edge nets + predicted-FFT rebalance post-pass.
-    -- Shard count comes from `--shards N`, or NAIVELY from `--max-ram G`:
-    -- without a profile the planner cannot know a shard's real prover
-    -- peak, so it estimates it from serialized env bytes via a measured
-    -- amplification factor and picks N so the estimated per-shard peak
-    -- fits the budget. The projections printed by an executed run
-    -- (`ix check --ixes --batch`) are the ground truth that corrects
-    -- the estimate — over-budget shards re-split, far-under merge.
+    -- `--shards N` fixes the count. Under `--max-ram G`, Rust chooses a
+    -- seed only after building the static block profile: the fitted owned
+    -- score sees both bytes and their per-block shape, unlike `.ixe` file
+    -- size. Boundaries and budget fitting are still measured where execution
+    -- happens anyway (the prove gate splits over-budget shards inline and the
+    -- corrected manifest remembers the leaves).
     if maxCycles.isSome then
       p.printError "error: --max-cycles requires --profile (its budget \
         model is calibrated on profiled op counters)"
       return 1
-    let n ← match shardsFlag, maxRam with
-      | some n, _ => pure n
-      | none, some gib =>
-        if gib == 0 then
-          p.printError "error: --max-ram must be positive"; return 1
-        let envBytes := (← System.FilePath.metadata envPath).byteSize.toNat
-        -- Prover-peak-per-env-byte, measured on init and FLT partitions
-        -- (2026-08-21): analytic prover peaks landed at ~20,000-21,000x
-        -- the shard's serialized bytes. Target ~2/3 of the budget so
-        -- the median sits under it with headroom for the measured
-        -- ~2.5x median-to-max spread across shards of one partition.
-        let amplification := 20000
-        let targetBytes := gib * 1024 * 1024 * 1024 * 2 / 3
-        let n := max 1 ((envBytes * amplification + targetBytes - 1) / targetBytes)
-        IO.println s!"[shard] naive RAM sizing: {envBytes} env bytes × \
-          {amplification} / ({gib} GiB × 2/3) → {n} shard(s)"
-        pure n
-      | none, none =>
-        p.printError "error: the static strategy (no --profile) requires \
-          --shards N or --max-ram G"
-        return 1
-    IO.println s!"Sharding {envPath} into {n} shards (static strategy, balance ±{balancePct}%)"
-    rsShardEnvStaticFFI envPath (toString n) (toString balancePct) outPath
+    match shardsFlag, maxRam with
+    | some n, _ =>
+      if n == 0 then
+        p.printError "error: --shards must be positive"; return 1
+      IO.println s!"Sharding {envPath} into {n} shards \
+        (static strategy, balance ±{balancePct}%)"
+      rsShardEnvStaticFFI envPath (toString n) "0" (toString balancePct) outPath
+    | none, some gib =>
+      if gib == 0 then
+        p.printError "error: --max-ram must be positive"; return 1
+      IO.println s!"Sharding {envPath} for a {gib} GiB prover budget \
+        (static block-shape seed, balance ±{balancePct}%)"
+      rsShardEnvStaticFFI envPath "0" (toString gib) (toString balancePct) outPath
+    | none, none =>
+      p.printError "error: the static strategy (no --profile) requires \
+        --shards N or --max-ram G"
+      return 1
   | some espPath =>
     -- Profiled strategy, unchanged: partition the `.ixprof`.
     -- Precedence: explicit --shards (fixed count) > explicit --max-cycles/--max-ram
@@ -199,7 +196,7 @@ def runShardCmd (p : Cli.Parsed) : IO UInt32 := do
 
 end Ix.Cli.ShardCmd
 
-open Ix.Cli.ShardCmd in
+open Ix.Cli.ShardCmd Ix.Cli.RefineCmd in
 def shardCmd : Cli.Cmd := `[Cli|
   "shard" VIA runShardCmd;
   "Partition a `.ixe` env into shards: static strategy by default (`--shards N`, no kernel run), or the profiled pipeline via `--profile <path.ixprof>`"
@@ -208,7 +205,7 @@ def shardCmd : Cli.Cmd := `[Cli|
     profile      : String; "Path to a `.ixprof` from `ix profile`. When given, use the profiled strategy (cap budgeting / balanced min-cut over measured costs); when absent, the static strategy partitions the `.ixe` directly."
     shards       : Nat;    "Fixed number of shards N (static strategy; overrides --max-ram sizing and the profiled default budget sizing)"
     "max-cycles" : Nat;    "Per-shard guest-cycle budget (profiled strategy only)"
-    "max-ram"    : Nat;    "Per-shard prover-RAM budget, GiB. Static strategy: NAIVE sizing — estimates per-shard prover peak from serialized env bytes (measured ~20,000x amplification) and picks the shard count so the estimate fits ~2/3 of the budget; executed projections then correct it (split/merge). Profiled strategy: budget from measured op counters (default: detected system RAM)."
+    "max-ram"    : Nat;    "Per-shard prover-RAM budget, GiB. Static strategy: seed the shard count from the `.ixe` block-shape score (serialized block size + a superlinear large-body term), with fitted scale and budget exponents anchored at Mathlib; the execution gate measures and corrects every boundary. Profiled strategy: budget from measured op counters (default: detected system RAM)."
     balance      : Nat;    "Per-bisection balance tolerance, percent (default 5)"
     parallelism  : Nat;    "Provers assumed for the prove-time estimate (profiled strategy only; default 1 = sequential)"
     out          : String; "Output .ixes manifest path (default: env base name + `.ixes`, e.g. init.ixe → init.ixes)"
@@ -218,7 +215,9 @@ def shardCmd : Cli.Cmd := `[Cli|
 
   SUBCOMMANDS:
     shardExtractCmd;
-    shardGraphCmd
+    shardGraphCmd;
+    shardRefineCmd;
+    shardClaimsCmd
 ]
 
 end
diff --git a/Ix/Cli/ShardProofIndex.lean b/Ix/Cli/ShardProofIndex.lean
new file mode 100644
index 000000000..500ac2aa9
--- /dev/null
+++ b/Ix/Cli/ShardProofIndex.lean
@@ -0,0 +1,86 @@
+/-
+  The shard-proof index: `~/.ix/cache/shard-proofs/<claim-digest-hex>` holds
+  the store address of an `Ixon.Proof` wrapper whose bundled `CheckEnv` claim
+  has that digest. It is what lets a partially proved partition resume after
+  a refinement: a leaf's identity is its claim digest, never its manifest
+  index. An index entry is an untrusted hint — readers decode the wrapper,
+  compare the bundled claim with the one they expect and verify the proof
+  natively before reusing it, the aggregate cache's discipline.
+-/
+module
+public import Ix.Address
+public import Ix.Aiur.Compiler
+public import Ix.Aiur.Protocol
+public import Ix.Claim
+public import Ix.Ixon
+public import Ix.Store
+public import Ix.IxVM.ClaimHarness
+
+public section
+
+namespace Ix.Cli.ShardProofIndex
+
+/-- The index directory: the global `~/.ix/cache/shard-proofs`, or a hermetic
+    root for tests. -/
+def indexDir (cacheRoot? : Option System.FilePath := none) : IO System.FilePath := do
+  match cacheRoot? with
+  | some root =>
+    let dir := root / "shard-proofs"
+    IO.FS.createDirAll dir
+    pure dir
+  | none => StoreIO.toIO (Store.cacheDir "shard-proofs")
+
+/-- Read an index entry. A missing or malformed entry is a miss, never an
+    error: store loading and verification happen separately. -/
+def readAddress (dir : System.FilePath) (digest : Address) : IO (Option Address) := do
+  let path := dir / toString digest
+  if !(← path.pathExists) then return none
+  try
+    let raw ← IO.FS.readFile path
+    pure (Address.fromString raw.trimAscii.toString)
+  catch _ => pure none
+
+/-- Atomically replace one index entry. -/
+def writeAddress (dir : System.FilePath) (digest addr : Address) : IO Unit := do
+  let tmp := dir / s!"{digest}.tmp"
+  IO.FS.writeFile tmp s!"{addr}\n"
+  IO.FS.rename tmp (dir / toString digest)
+
+/-- Native verification of a persisted shard-proof wrapper against the claim
+    the caller expects: the wrapper must decode, bundle exactly `expected`,
+    and its proof must verify under `verify_claim`'s public input for that
+    claim (the same check `ix verify --shard K` performs). -/
+def verifyWrapper (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel)
+    (expected : Ix.Claim) (proofAddr : Address) : IO (Except String Unit) := do
+  try
+    let bytes ← StoreIO.toIO (Store.read proofAddr)
+    match Ixon.Proof.de bytes with
+    | .error e => pure (.error s!"wrapper {proofAddr} does not decode: {e}")
+    | .ok wrapper =>
+      if wrapper.claim != expected then
+        return .error s!"wrapper {proofAddr} bundles a different claim"
+      match Aiur.Proof.ofBytesChecked wrapper.proof with
+      | .error e => pure (.error s!"proof {proofAddr} does not decode: {e}")
+      | .ok proof =>
+        let some funIdx := compiled.getFuncIdx `verify_claim
+          | return .error "`verify_claim` entrypoint missing from compiled toplevel"
+        let input := IxVM.ClaimHarness.packedDigestKey
+          (Address.blake3 (Ix.Claim.ser wrapper.claim))
+        match aiurSystem.verify (Aiur.buildClaim funIdx input #[]) proof with
+        | .ok () => pure (.ok ())
+        | .error e => pure (.error s!"proof {proofAddr} does not verify: {e}")
+  catch e => pure (.error s!"{e}")
+
+/-- The address of a verified proof of `expected`, if the index has one.
+    An entry that fails any check is reported and treated as a miss. -/
+def verifiedProof (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel)
+    (dir : System.FilePath) (expected : Ix.Claim) : IO (Option Address) := do
+  let digest := Address.blake3 (Ix.Claim.ser expected)
+  let some addr ← readAddress dir digest | return none
+  match ← verifyWrapper aiurSystem compiled expected addr with
+  | .ok () => pure (some addr)
+  | .error e =>
+    IO.eprintln s!"[shard-proofs] index entry for {digest} ignored: {e}"
+    pure none
+
+end Ix.Cli.ShardProofIndex
diff --git a/Ix/Cli/VerifyCmd.lean b/Ix/Cli/VerifyCmd.lean
index 8eb65094b..4fed82ecd 100644
--- a/Ix/Cli/VerifyCmd.lean
+++ b/Ix/Cli/VerifyCmd.lean
@@ -18,8 +18,12 @@ public import Ix.Common
 public import Ix.IxVM
 public import Ix.IxVM.Toplevel
 public import Ix.IxVM.ClaimHarness
+public import Ix.Aggr
+public import Ix.MultiStark
 public import Ix.Store
+public import Ix.Cli.AggregateCmd
 public import Ix.Cli.CheckCmd
+public import Ix.Cli.ShardProofIndex
 
 public section
 
@@ -50,7 +54,11 @@ def verifyOneProof (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledTople
     (proofAddr : Address) : IO UInt32 := do
   let bytes ← StoreIO.toIO (Store.read proofAddr)
   let wrapper ← IO.ofExcept (Ixon.Proof.de bytes)
-  let proof := Aiur.Proof.ofBytes wrapper.proof
+  let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with
+    | .ok proof => pure proof
+    | .error e =>
+      IO.eprintln s!"error: proof {proofAddr} does not decode: {e}"
+      return 1
   -- `verify_claim` takes the packed 8-G blake3 digest of the serialized
   -- claim (4 LE bytes per element; see `ClaimHarness.packedDigestKey`).
   let claimDigest := Address.blake3 (Ix.Claim.ser wrapper.claim)
@@ -79,6 +87,105 @@ def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel))
     | .ok compiled =>
       return .ok (Aiur.AiurSystem.build compiled.bytecode commitmentParameters friParameters, compiled)
 
+structure AggregateBackend where
+  system : Aiur.AiurSystem
+  aggrIdx : Aiur.Bytecode.FunIdx
+  allowed : ByteArray
+
+structure ExpectedAggregate where
+  claim : Ix.Claim
+
+/-- Build the two deterministic systems whose identities are committed by an
+aggregate root: the IxVM vk and the single-entrypoint recursion vk. -/
+private def buildAggregateBackend
+    (recursionParameters : MultiStark.RecursionParameters) :
+    IO (Except String AggregateBackend) := do
+  let ixvmCompiled ← match IxVM.ixVM with
+    | .error e => return .error s!"IxVM toplevel merging failed: {e}"
+    | .ok top => match top.compile with
+      | .error e => return .error s!"IxVM compilation failed: {e}"
+      | .ok compiled => pure compiled
+  let aggrCompiled ← match Aggr.ixAggr with
+    | .error e => return .error s!"recursion toplevel merging failed: {e}"
+    | .ok top => match top.compile with
+      | .error e => return .error s!"recursion compilation failed: {e}"
+      | .ok compiled => pure compiled
+  let verifyIdx := ixvmCompiled.getFuncIdx `verify_claim |>.get!
+  let aggrIdx := aggrCompiled.getFuncIdx `ix_aggr |>.get!
+  let ixvmSystem := Aiur.AiurSystem.build ixvmCompiled.bytecode
+    commitmentParameters friParameters
+  let aggrSystem := MultiStark.buildRecursionSystem aggrCompiled.bytecode
+    recursionParameters
+  let ixvmVk := ixvmSystem.vkBytes
+  let aggrVk := aggrSystem.vkBytes
+  let allowed := Aggr.allowedBlob ixvmVk verifyIdx aggrVk aggrIdx
+  return .ok {
+    system := aggrSystem
+    aggrIdx
+    allowed
+  }
+
+private def shardStatement (env : Ixon.Env) (blocks : Array Address) :
+    Except String Aggr.CheckEnvTrees := do
+  let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks env blocks
+  let (claim, trees) ← IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned
+  Aggr.CheckEnvTrees.ofClaim claim trees
+
+/-- Reproduce the flat/structural statement fold from a coverage-validated
+manifest. Zero-constant leaves are pruned exactly as in `ix aggregate`; no proof
+data is needed. -/
+def expectedFromManifest (env : Ixon.Env)
+    (view : Ix.Cli.CheckCmd.IxesManifestView) (structuralAbove : Nat) :
+    Except String Aggr.CheckEnvTrees := do
+  let (view, counts) ← view.pruneEmpty env
+  let plan ← Ix.Cli.AggregateCmd.schedulePlan view.aggregationTree.foldPlan
+    counts structuralAbove
+  let mut slots : Array Aggr.CheckEnvTrees := #[]
+  for item in plan do
+    match item.op with
+    | .leaf shard =>
+      let some blocks := view.shards[shard]?
+        | throw s!"aggregate plan references missing shard {shard}"
+      slots := slots.push (← shardStatement env blocks)
+    | .join left right =>
+      let some leftStatement := slots[left]?
+        | throw s!"aggregate plan references missing left slot {left}"
+      let some rightStatement := slots[right]?
+        | throw s!"aggregate plan references missing right slot {right}"
+      slots := slots.push <| if item.structural then
+        leftStatement.joinStructural rightStatement
+      else
+        leftStatement.join rightStatement
+  let some root := slots.back? | throw "aggregate manifest produced no root"
+  pure root
+
+private def verifyAggregateProof (backend : AggregateBackend)
+    (expected? : Option ExpectedAggregate) (proofAddr : Address) : IO UInt32 := do
+  let wrapper ← IO.ofExcept (Ixon.Proof.de (← StoreIO.toIO (Store.read proofAddr)))
+  let .checkEnv _ _ := wrapper.claim | do
+    IO.eprintln s!"error: aggregate proof {proofAddr} does not bundle a CheckEnv claim"
+    return 1
+  match expected? with
+  | some expected =>
+    if wrapper.claim != expected.claim then
+      IO.eprintln s!"error: aggregate claim {wrapper.claim} does not match expected {expected.claim}"
+      return 1
+  | none => pure ()
+  let proof ← match Aiur.Proof.ofBytesChecked wrapper.proof with
+    | .ok proof => pure proof
+    | .error e =>
+      IO.eprintln s!"error: aggregate proof {proofAddr} does not decode: {e}"
+      return 1
+  let outerClaim := Ix.Cli.AggregateCmd.aggregateOuterClaim
+    backend.allowed backend.aggrIdx wrapper.claim
+  match backend.system.verify outerClaim proof with
+  | .ok () =>
+    IO.println s!"ok: aggregate proof {proofAddr} verifies {wrapper.claim}"
+    return 0
+  | .error e =>
+    IO.eprintln s!"error: aggregate verification failed: {e}"
+    return 1
+
 /-- Shard-aware verification (parity with `check`/`prove`):
     - `--shard K`, no proof: print shard K's reconstructed `CheckEnv` claim
       digest (the public input its proof must commit).
@@ -88,10 +195,17 @@ def buildBackend : IO (Except String (Aiur.AiurSystem × Aiur.CompiledToplevel))
     - no `--shard` + proofs: composed verdict — coverage, every proof bound to a
       shard, and every shard covered by a valid proof. -/
 def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat)
-    (proofs : List String) : IO UInt32 := do
+    (proofs : List String) (record : Bool := false) : IO UInt32 := do
   let (ixonEnv, shards) ← match (← Ix.Cli.CheckCmd.loadEnvAndShards manifestPath ixePath) with
     | .error e => IO.eprintln e; return 1
     | .ok r => pure r
+  -- `--record`: a proof that binds to its shard and verifies is indexed
+  -- under its claim digest, for `ix prove --skip-proven` / `ix shard refine`.
+  let indexDir? ← if record then some <$> Ix.Cli.ShardProofIndex.indexDir else pure none
+  let recordProof (digest proofAddr : Address) : IO Unit := do
+    if let some dir := indexDir? then
+      Ix.Cli.ShardProofIndex.writeAddress dir digest proofAddr
+      IO.println s!"[verify] recorded {proofAddr} for claim {digest} in the shard-proof index"
   let digestOf (k : Nat) : IO (Option Address) := do
     match shards[k]? with
     | none => IO.eprintln s!"shard {k} out of range ({shards.size} shards)"; pure none
@@ -118,6 +232,7 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat
         IO.eprintln s!"[verify] FAIL: proof {proofAddr} (claim {d}) is not shard {k} (claim {expected})"
         rc := 1
       else if (← verifyOneProof aiurSystem compiled proofAddr) != 0 then rc := 1
+      else recordProof d proofAddr
     return rc
   | none =>
     if !(← Ix.Cli.CheckCmd.shardsCover ixonEnv shards) then return 1
@@ -137,7 +252,9 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat
       | none => IO.eprintln s!"[verify] FAIL: proof {proofAddr} (claim {d}) matches no shard"; rc := 1
       | some k =>
         if (← verifyOneProof aiurSystem compiled proofAddr) != 0 then rc := 1
-        else covered := covered.insert k
+        else
+          covered := covered.insert k
+          recordProof d proofAddr
     let missing := (List.range shards.size).filter (fun k => !covered.contains k)
     if !missing.isEmpty then
       IO.eprintln s!"[verify] FAIL: shards lacking a valid proof: {missing}"
@@ -146,11 +263,63 @@ def verifyShardComposition (ixePath manifestPath : String) (shardK? : Option Nat
       IO.println s!"[verify] OK: composed verdict — all {shards.size} shards proven + disjoint cover"
     return rc
 
-def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do
+/-- Verify with an explicit aggregate-recursion configuration. Ordinary IxVM
+proof verification remains pinned to its independent canonical parameters. -/
+def runVerifyCmdWith (recursionParameters : MultiStark.RecursionParameters)
+    (p : Cli.Parsed) : IO UInt32 := do
   let proofs := (p.variableArgsAs! String).toList
+  if p.hasFlag "aggregate" then
+    if proofs.isEmpty then
+      p.printError "error: --aggregate requires at least one aggregate proof address"
+      return 1
+    let ixePath? := (p.flag? "ixe").map (·.as! String)
+    let manifestPath? := (p.flag? "ixes").map (·.as! String)
+    if manifestPath?.isSome && ixePath?.isNone then
+      p.printError "error: aggregate verification with --ixes also requires --ixe"
+      return 1
+    let structuralAbove := ((p.flag? "structural-above").map (·.as! Nat)).getD
+      Ix.Cli.AggregateCmd.defaultStructuralAbove
+    let expected? ← match ixePath?, manifestPath? with
+      | none, none => pure none
+      | some ixePath, none =>
+        let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with
+          | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1
+          | .ok env => pure env
+        let some expectedTree := IxVM.ClaimHarness.envCanonicalTree env | do
+          IO.eprintln "error: cannot verify an aggregate against an empty environment"
+          return 1
+        pure (some { claim := .checkEnv expectedTree.root none })
+      | some ixePath, some manifestPath =>
+        let env ← match Ixon.deEnvAnon (← IO.FS.readBinFile ixePath) with
+          | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1
+          | .ok env => pure env
+        let view ← match Ix.Cli.CheckCmd.parseIxesManifest
+            (← IO.FS.readBinFile manifestPath) with
+          | .error e => IO.eprintln s!"manifest parse failed: {e}"; return 1
+          | .ok view => pure view
+        if !(← Ix.Cli.CheckCmd.shardsCover env view.shards) then return 1
+        let statement ← match expectedFromManifest env view structuralAbove with
+          | .error e => IO.eprintln e; return 1
+          | .ok expected => pure expected
+        if statement.assumptions.isSome then
+          IO.eprintln s!"error: expected aggregate root retains assumptions \
+            {statement.assumptions.map (·.root)}"
+          return 1
+        pure (some { claim := statement.claim })
+      | none, some _ => unreachable!
+    let backend ← match ← buildAggregateBackend recursionParameters with
+      | .error e => IO.eprintln e; return 1
+      | .ok backend => pure backend
+    let mut rc : UInt32 := 0
+    for hex in proofs do
+      let proofAddr ← addrOfHex! "aggregate proof" hex
+      if (← verifyAggregateProof backend expected? proofAddr) != 0 then
+        rc := 1
+    return rc
   match (p.flag? "ixe").map (·.as! String), (p.flag? "ixes").map (·.as! String) with
   | some ixe, some manifest =>
     verifyShardComposition ixe manifest ((p.flag? "shard").map (·.as! Nat)) proofs
+      (p.hasFlag "record")
   | _, _ =>
     if proofs.isEmpty then
       p.printError "error: must specify <proof-hex>... (or --ixe + --ixes for a shard partition)"
@@ -164,6 +333,9 @@ def runVerifyCmd (p : Cli.Parsed) : IO UInt32 := do
       if (← verifyOneProof aiurSystem compiled proofAddr) != 0 then rc := 1
     return rc
 
+def runVerifyCmd (p : Cli.Parsed) : IO UInt32 :=
+  runVerifyCmdWith MultiStark.defaultRecursionParameters p
+
 end Ix.Cli.VerifyCmd
 
 open Ix.Cli.VerifyCmd in
@@ -173,8 +345,11 @@ def verifyCmd : Cli.Cmd := `[Cli|
 
   FLAGS:
     "ixe"  : String; "Path to a serialized `.ixe` env (with --ixes). With no proof args and no --shard: verify the partition off-circuit (every constant owned by exactly one shard)."
-    "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe)."
+    "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). For aggregate roots, reproduces the manifest-relative hybrid structural root."
     "shard" : Nat;   "0-based shard index K (with --ixe + --ixes). No proof: print shard K's reconstructed CheckEnv claim digest. With proof(s): bind each to shard K and verify."
+    "aggregate";      "Interpret proofs as single-entrypoint aggregate roots. With --ixe, bind the canonical environment claim; add --ixes for the exact manifest-relative hybrid root."
+    "structural-above" : Nat; "For --aggregate + --ixes, reproduce structural joins above N subject leaves (default 4096; must match proving)."
+    "record";         "With --ixe + --ixes and proof(s): after a proof binds to its shard and verifies, record it in the shard-proof index (`~/.ix/cache/shard-proofs/<claim-digest>` → address) so `ix prove --skip-proven` and `ix shard refine` reuse it. How already-proved leaves are imported before a refinement."
 
   ARGS:
     ...proofs : String; "32-byte hex address(es) of persisted `Ixon.Proof` wrappers in `~/.ix/store/`. Omit when using --ixe + --ixes."
diff --git a/Ix/Common.lean b/Ix/Common.lean
index 52a2308f9..add05a783 100644
--- a/Ix/Common.lean
+++ b/Ix/Common.lean
@@ -439,17 +439,24 @@ def Nat.formatMs (ms : Nat) : String :=
   else
     "< 1ms"
 
+/-- Bytes per GiB — the unit of the RAM-budget flags and every
+    prover-peak log line. -/
+def gibBytes : Nat := 1024 * 1024 * 1024
+
+/-- Bytes rendered as GiB for log lines. -/
+def toGib (bytes : Nat) : Float := bytes.toFloat / gibBytes.toFloat
+
 /-- Format a byte count with appropriate unit suffix (B, kB, MB, GB). -/
 def fmtBytes (n : Nat) : String :=
   if n < 1024 then s!"{n} B"
   else if n < 1024 * 1024 then
     let kb := n * 10 / 1024
     s!"{kb / 10}.{kb % 10} kB"
-  else if n < 1024 * 1024 * 1024 then
+  else if n < gibBytes then
     let mb := n * 10 / (1024 * 1024)
     s!"{mb / 10}.{mb % 10} MB"
   else
-    let gb := n * 10 / (1024 * 1024 * 1024)
+    let gb := n * 10 / gibBytes
     s!"{gb / 10}.{gb % 10} GB"
 
 /-- ` · rss X.Y GiB (hwm Z.W)` from `/proc/self/status`; empty where
diff --git a/Ix/IxVM/ClaimHarness.lean b/Ix/IxVM/ClaimHarness.lean
index 4af4cd798..3ff64c994 100644
--- a/Ix/IxVM/ClaimHarness.lean
+++ b/Ix/IxVM/ClaimHarness.lean
@@ -400,7 +400,13 @@ composition of per-piece check-env claims"
   return { funcName := `verify_claim
            input := digestKey, inputIOBuffer := ioBuffer }
 
-/-- the kernel shard claim with a THIN frontier: asm = the DIRECT out-of-owned
+/-- The kernel shard claim and its canonical subject/assumption trees, without
+    constructing the witness byte closure. This is the claim-only path used by
+    aggregation and verification: those callers need the Merkle trees but do
+    not consume the dependency bytes, so walking the full closure would be
+    pure discarded work.
+
+    The frontier is THIN: asm = the DIRECT out-of-owned
     walk edges (refs + Prj→block) of the owned constants, not the full
     `closure ∖ owned`. the kernel's env walk exits the shard only through a
     direct external edge and stops there, so everything below the first
@@ -412,15 +418,9 @@ composition of per-piece check-env claims"
     from `env.consts` is not something the kernel walk can reach, so
     including it would inflate the asm tree and break digest agreement
     between the Rust prover and this verifier. -/
-def shardCheckEnvClaim (env : Ixon.Env) (owned : Array Address) :
-    Except String (Ix.Claim × Std.HashSet Address × Std.HashMap Address Ix.AssumptionTree) := do
+def shardCheckEnvClaimTrees (env : Ixon.Env) (owned : Array Address) :
+    Except String (Ix.Claim × Std.HashMap Address Ix.AssumptionTree) := do
   let ownedSet : Std.HashSet Address := owned.foldl (·.insert ·) {}
-  let closure : Std.HashSet Address := Id.run do
-    let mut s : Std.HashSet Address := {}
-    for a in owned do
-      for x in (closureFrom env a).toArray do
-        s := s.insert x
-    return s
   let frontier : Array Address := Id.run do
     let mut fs : Std.HashSet Address := {}
     for o in owned do
@@ -457,10 +457,22 @@ def shardCheckEnvClaim (env : Ixon.Env) (owned : Array Address) :
   match asmTree? with
   | some asmTree => trees := trees.insert asmTree.root asmTree
   | none => pure ()
+  pure (claim, trees)
+
+/-- Claim/tree construction plus the byte closure needed by a Lean-built shard
+    witness. Reachability distributes over root union, so one graph walk from
+    all owned and primitive roots is exactly the old union of one
+    `closureFrom` walk per owned constant, without repeatedly traversing the
+    same shared dependency core. -/
+def shardCheckEnvClaim (env : Ixon.Env) (owned : Array Address) :
+    Except String (Ix.Claim × Std.HashSet Address × Std.HashMap Address Ix.AssumptionTree) := do
+  let (claim, trees) ← shardCheckEnvClaimTrees env owned
+  let primitiveRoots := Ix.Tc.primAddrSet.toArray.filter env.consts.contains
+  let closure := closureFromRoots env (owned ++ primitiveRoots)
   pure (claim, closure, trees)
 
 /-- Variant of `buildShardCheckEnvWitness`: THIN frontier asm (see
-    `shardCheckEnvClaim`) with the `closureFrom` byte scope, which
+    `shardCheckEnvClaimTrees`) with the `closureFrom` byte scope, which
     carries the IPrj/CPrj/RPrj/DPrj wrappers the kernel's `get_ci`
     synthesizes via kernel-side blake3 as forward Muts→wrapper edges. -/
 def buildShardCheckEnvWitness (env : Ixon.Env) (owned : Array Address) :
diff --git a/Ix/IxVM/Core.lean b/Ix/IxVM/Core.lean
index a32e74d71..619ba613e 100644
--- a/Ix/IxVM/Core.lean
+++ b/Ix/IxVM/Core.lean
@@ -18,6 +18,16 @@ def core := ⟦
     None
   }
 
+  -- Memoized u32 comparison for hot structural and frontier walks. Aiur
+  -- memoizes function calls automatically, so keeping the decomposition in
+  -- this shared helper avoids charging the wide intrinsic layout repeatedly;
+  -- recurring `(a, b)` pairs share one constrained helper row. This belongs
+  -- in Core because both the IxVM substitution circuits and the recursive
+  -- multi-STARK verifier rely on the same optimization.
+  fn memo_u32_less_than(a: G, b: G) -> G {
+    u32_less_than(a, b)
+  }
+
   -- Interned 32-element address (blake3 content hash).
   --
   -- DIFFERENT POINTER VALUES DO NOT IMPLY DIFFERENT DATA. The Aiur
diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean
index 5250e5815..1a1b8bef9 100644
--- a/Ix/IxVM/Kernel/Subst.lean
+++ b/Ix/IxVM/Kernel/Subst.lean
@@ -90,14 +90,6 @@ def subst := ⟦
     }
   }
 
-  -- Memoized structural comparison used by substitution fast paths. Keeping
-  -- the u32 decomposition in this helper avoids charging its wide intrinsic
-  -- layout on every row of a hot substitution circuit; repeated `(depth,lbr)`
-  -- pairs share one constrained helper row.
-  fn memo_u32_less_than(a: G, b: G) -> G {
-    u32_less_than(a, b)
-  }
-
   -- ============================================================================
   -- has_bvar_in_range
   --
diff --git a/Ix/KernelCheck.lean b/Ix/KernelCheck.lean
index d403997a5..3c72b13e0 100644
--- a/Ix/KernelCheck.lean
+++ b/Ix/KernelCheck.lean
@@ -194,15 +194,17 @@ opaque rsEnvExtractFFI :
     @& Bool →                            -- quiet
     IO Unit
 
-/-- FFI: partition a `.ixe` into `numShards` shards with the STATIC
-    strategy (no out-of-circuit profiling): byte-balanced min-cut over the
-    static walk-edge nets + a predicted-FFT-cost rebalance post-pass
-    (`ix_kernel::shard::shard_static`; model constants documented there).
-    Writes a `.ixes` manifest; prints the report to stderr. -/
+/-- FFI: partition a `.ixe` with the STATIC strategy (no out-of-circuit
+    profiling): byte-balanced min-cut over the static walk-edge nets + a
+    predicted-FFT-cost rebalance post-pass (`ix_kernel::shard::shard_static`;
+    model constants documented there). A nonzero `numShards` fixes the count;
+    otherwise `ramGib` selects the static block-shape seed after the `.ixe` has
+    been profiled. Writes a `.ixes` manifest; prints the report to stderr. -/
 @[extern "rs_shard_env_static"]
 opaque rsShardEnvStaticFFI :
     @& String →                          -- .ixe path
-    @& String →                          -- num_shards (N)
+    @& String →                          -- num_shards (N; "0" = score seed)
+    @& String →                          -- max RAM GiB (used when N = 0)
     @& String →                          -- balance percent
     @& String →                          -- .ixes output path ("" = skip)
     IO Unit
diff --git a/Ix/MultiStark.lean b/Ix/MultiStark.lean
index d093328b3..393b7eb07 100644
--- a/Ix/MultiStark.lean
+++ b/Ix/MultiStark.lean
@@ -2,10 +2,13 @@ module
 public import Blake3.Rust
 public import Ix.Aiur.Meta
 public import Ix.Aiur.Protocol
+public import Ix.AssumptionTree
 public import Ix.IxVM.Core
 public import Ix.IxVM.ByteStream
 public import Ix.IxVM.Blake3
 public import Ix.MultiStark.Goldilocks
+public import Ix.MultiStark.Aggregate
+public import Ix.MultiStark.Host
 public import Ix.MultiStark.Deserialize
 public import Ix.MultiStark.Keccak
 public import Ix.MultiStark.Pcs
@@ -14,9 +17,9 @@ public import Ix.MultiStark.Verifier
 public import Ix.MultiStark.Tests
 
 /-!
-# Multi-STARK proof verifier (Aiur)
+# Multi-STARK proof verifier and binary join (Aiur)
 
-The recursive verifier. Its public statement is purely existential: *"there
+The lift entrypoint's public statement is purely existential: *"there
 exists a valid multi-stark proof for the constraint system with this Blake3
 digest and these public claims."* The FRI parameters (blowup, query count,
 PoW bits, …) are NOT separate public inputs: they live in the verifying key,
@@ -31,6 +34,12 @@ statement, while costing an extra in-circuit hash over those bytes.
 The verifying key and claims, by contrast, ARE digest-bound (`system_digest`,
 `claims_digest`): they determine *what was proven*.
 
+The two production join entrypoints verify lift/join proofs under one pinned
+recursion vk and fold their `CheckEnv` statements. `join_two` uses canonical
+subject union; `join_two_structural` commits to a root-of-roots and discharges
+assumptions with Merkle paths. Their implementation lives in
+`Ix/MultiStark/Aggregate.lean`.
+
 Fixed protocol assumptions (our system): `capHeight = 0`, `maxLogArity = 1`,
 `logFinalPolyLen = 0`. The variable FRI parameters (`num_queries`,
 `commit_pow_bits`, `query_pow_bits`, `log_blowup`) are read from the
@@ -88,7 +97,7 @@ def entrypoints := ⟦
 
 /-- The FULL Multi-STARK verifier toplevel: `core` (lists/options) +
 `byteStream` (`U64`, `flatten_u64`, `read_byte_stream`, …) + the deserializer,
-the Blake3 hash, and the entrypoint — unpruned, including entries inherited
+the Blake3 hash, and both production entrypoints — unpruned, including entries inherited
 from the shared modules (`blake3_test`/`blake3_bench`). Only `multiStarkTests`
 builds on this; production uses `multiStark` (pruned). -/
 def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do
@@ -99,16 +108,19 @@ def multiStarkFull : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← t.merge systemDeserialize
   let t ← t.merge pcs
   let t ← t.merge verifier
+  let t ← t.merge aggregate
   t.merge entrypoints
 
-/-- The production Multi-STARK verifier toplevel: `multiStarkFull` pruned to
-`verify_multi_stark_proof`'s call closure. Every compiled function is a
-committed circuit whose openings pad every proof of the verifier's execution,
-so functions only reachable from unrelated entries (kernel-oriented helpers of
-the shared modules, test/bench entries) cost real proof bytes if kept. -/
+/-- The production recursion toplevel: `multiStarkFull` pruned to the combined
+call closures of `verify_multi_stark_proof` (lift), `join_two` (flat join), and
+`join_two_structural`. Every
+compiled function is a committed circuit whose openings pad every proof of the
+system's execution, so functions only reachable from unrelated entries
+(kernel-oriented helpers of the shared modules, test/bench entries) cost real
+proof bytes if kept. -/
 def multiStark : Except Aiur.Global Aiur.Source.Toplevel := do
   let t ← multiStarkFull
-  pure (t.prune [`verify_multi_stark_proof])
+  pure (t.prune [`verify_multi_stark_proof, `join_two, `join_two_structural])
 
 /-! ## Lean-side input assembly
 
@@ -120,6 +132,46 @@ digest-bound. These helpers are that recipe's single home. -/
 def u64le (n : Nat) : Array UInt8 :=
   (Array.range 8).map (fun i => UInt8.ofNat ((n >>> (8 * i)) % 256))
 
+/-! ## Recursion proof parameters
+
+IxVM proofs and aggregate recursion proofs deliberately have separate host
+configuration, even while both configurations retain today's canonical values.
+Keeping the recursion pair here gives aggregation and aggregate verification a
+single construction path; a later policy change cannot silently update only one
+side.
+-/
+
+/-- Commitment and FRI parameters for lift/join proofs. These parameters are
+already bound by `AiurSystem.vkBytes`; this structure is host configuration, not
+an additional circuit public input. -/
+structure RecursionParameters where
+  commitment : Aiur.CommitmentParameters
+  fri : Aiur.FriParameters
+
+/-- Compatibility default for aggregate recursion proofs. Policy changes (for
+example, reducing the query count) must be explicit updates to this value and
+must not change the canonical IxVM proof parameters. -/
+def defaultRecursionParameters : RecursionParameters := {
+  commitment := Aiur.defaultCommitmentParameters
+  fri := Aiur.defaultFriParameters
+}
+
+/-- Stable 40-byte serialization used as the `fri_params_ser` component of the
+future aggregate cache key: five `u64` little-endian fields in verifying-key
+order. Commitment parameters need no separate cache-key component because a
+change to them changes the recursion-vk digest that the key also contains. -/
+def RecursionParameters.cacheFriBytes (parameters : RecursionParameters) : ByteArray :=
+  let fri := parameters.fri
+  ⟨u64le fri.logFinalPolyLen ++ u64le fri.maxLogArity ++
+    u64le fri.numQueries ++ u64le fri.commitProofOfWorkBits ++
+    u64le fri.queryProofOfWorkBits⟩
+
+/-- Build a recursion proving/verifying system through the shared aggregate
+parameter path. Both `AggregateCmd` and `VerifyCmd` use this helper. -/
+def buildRecursionSystem (bytecode : Aiur.Bytecode.Toplevel)
+    (parameters : RecursionParameters) : Aiur.AiurSystem :=
+  Aiur.AiurSystem.build bytecode parameters.commitment parameters.fri
+
 /-- Serialize public claims to `read_claims`'s wire format (which is also what
 the prover's Fiat-Shamir transcript observes): a length-prefixed list of
 length-prefixed claims, every word a little-endian `u64`. -/
@@ -136,16 +188,111 @@ def serializeClaims (claims : Array (Array Aiur.G)) : ByteArray := Id.run do
 digest, each as 8 packed-4-byte field elements (the entrypoint's format). The FRI parameters are read in-circuit from the digest-bound vk, not
 passed publicly. The proof/vk/claims advice itself goes through the
 natively-built IO buffer (`executeMultiStark` / `proveMultiStark`, which take
-the raw byte blobs directly: channel 0 = proof, 1 = vk, 2 = claims, each
-under key `[0]`). -/
+the raw byte blobs directly: channel 0 = the expanded proof advice returned by
+`AiurSystem.proofToAdviceBytes`, 1 = vk, 2 = claims, each under key `[0]`).
+The compact `Proof.toBytes` form is only for persistence and transport. -/
+def digestGs (bytes : ByteArray) : Array Aiur.G :=
+  let h := (Blake3.Rust.hash bytes).val.data
+  (Array.range 8).map fun i =>
+    .ofNat (h[4*i]!.toNat + 256 * h[4*i+1]!.toNat
+      + 65536 * h[4*i+2]!.toNat + 16777216 * h[4*i+3]!.toNat)
+
 def verifierPubInput (vkBytes claimBytes : ByteArray) : Array Aiur.G :=
-  let digestGs : ByteArray → Array Aiur.G := fun b =>
-    let h := (Blake3.Rust.hash b).val.data
-    (Array.range 8).map fun i =>
-      .ofNat (h[4*i]!.toNat + 256 * h[4*i+1]!.toNat
-        + 65536 * h[4*i+2]!.toNat + 16777216 * h[4*i+3]!.toNat)
   digestGs vkBytes ++ digestGs claimBytes
 
+/-! ## Aggregate-first input assembly
+
+These helpers define the host half of the recursive join wire contracts from
+`plans/aggregate-first-pipeline.md` §10.  Keeping the byte layout and digest
+packing next to `verifierPubInput` prevents the CLI, tests, and FFI callers from
+growing subtly different encodings while the join entrypoint is brought up.
+-/
+
+/-- The digest-bound 96-byte allowlist preimage for a recursive join:
+
+`blake3(ixvm vk) ‖ verify_claim index as u64-LE ‖ blake3(recursion vk) ‖
+lift index as u64-LE ‖ flat join index as u64-LE ‖ structural join index as
+u64-LE`.
+
+The verifying keys stay outside the public input. Their digests and all four
+entrypoint indices form the stable identity that every join in an aggregation
+tree pins transitively. The indices must be explicit because the Source DSL
+cannot materialize its compiler-assigned function index inside a circuit. -/
+def allowedBlob (ixvmVkBytes : ByteArray) (verifyClaimIdx : Nat)
+    (recursionVkBytes : ByteArray) (liftIdx joinIdx structuralJoinIdx : Nat) : ByteArray :=
+  let ixvmDigest := (Blake3.Rust.hash ixvmVkBytes).val.data
+  let recursionDigest := (Blake3.Rust.hash recursionVkBytes).val.data
+  ⟨ixvmDigest ++ u64le verifyClaimIdx ++ recursionDigest ++
+    u64le liftIdx ++ u64le joinIdx ++ u64le structuralJoinIdx⟩
+
+/-- Public input for either join entrypoint: the packed Blake3 digest of the
+allowlist blob followed by the packed digest of the output `CheckEnv` claim
+bytes. -/
+def joinPubInput (allowed outClaimBytes : ByteArray) : Array Aiur.G :=
+  digestGs allowed ++ digestGs outClaimBytes
+
+/-- Four little-endian bytes of `n`, used only by the compact native-FFI
+framing below. Join advice blobs are bounded by the `ByteArray`/Rust address
+space in practice and therefore never approach the `u32` limit. -/
+private def u32le (n : Nat) : Array UInt8 :=
+  (Array.range 4).map (fun i => UInt8.ofNat ((n >>> (8 * i)) % 256))
+
+/-- Encode content-addressed byte blobs for the native join FFI as
+
+`count:u32-LE ‖ (key:32 ‖ length:u32-LE ‖ payload)*`.
+
+The circuit still re-hashes/re-roots every payload. These host-side keys only
+make the advice addressable; they are not trusted bindings. -/
+private def joinKeyedBlobs
+    (entries : Array (ByteArray × ByteArray)) : ByteArray := Id.run do
+  assert! entries.size < 4294967296
+  let mut out := u32le entries.size
+  for (key, payload) in entries do
+    assert! key.size == 32
+    assert! payload.size < 4294967296
+    out := out ++ key.data ++ u32le payload.size ++ payload.data
+  return ⟨out⟩
+
+/-- Pack nested claim preimages for `executeMultiStarkJoin` /
+`proveMultiStarkJoin`. Each key is computed as Blake3(payload), matching IO
+channel 4's packed-digest lookup. -/
+def joinPreimagesBlob (preimages : Array ByteArray) : ByteArray :=
+  joinKeyedBlobs <| preimages.map fun bytes =>
+    ((Blake3.Rust.hash bytes).val, bytes)
+
+/-- Pack serialized canonical subject/assumption trees for the native join
+FFI. Channel 5 keys use the raw 32-byte tree root. The in-circuit loader
+independently checks strict leaf order and recomputes the canonical root. -/
+def joinTreesBlob (trees : Array Ix.AssumptionTree) : ByteArray :=
+  joinKeyedBlobs <| trees.map fun tree =>
+    (tree.root.hash, Ix.AssumptionTree.ser tree)
+
+/-- Encode one structural-discharge choice. A `none` path means "carry" and
+encodes as one zero byte. A present path means "discharge" and encodes as
+
+`1 ‖ count:u8 ‖ (side:u8 ‖ sibling:32)*`,
+
+where side `0` places the sibling on the left and side `1` places it on the
+right. Paths are bounded to 64 steps in both the host encoder and circuit. -/
+def joinPathPayload (path? : Option Ix.Merkle.MerklePath) : ByteArray := Id.run do
+  match path? with
+  | none => return ⟨#[0]⟩
+  | some path =>
+    assert! path.size ≤ 64
+    let mut out : Array UInt8 := #[1, UInt8.ofNat path.size]
+    for (sibling, isLeft) in path do
+      -- MerklePath's Bool says whether the sibling is on the left.
+      out := out.push (if isLeft then 0 else 1)
+      out := out ++ sibling.hash.data
+    return ⟨out⟩
+
+/-- Pack one structural-discharge choice per unique input-assumption candidate
+for IO channel 6. -/
+def joinPathsBlob
+    (paths : Array (Address × Option Ix.Merkle.MerklePath)) : ByteArray :=
+  joinKeyedBlobs <| paths.map fun (candidate, path?) =>
+    (candidate.hash, joinPathPayload path?)
+
 /-- The verifier toplevel PLUS its self-test entrypoints
 (`Ix/MultiStark/Tests.lean`), unpruned. Kept separate from `multiStark`
 because every `pub fn` adds a circuit to the compiled system — the production
diff --git a/Ix/MultiStark/Aggregate.lean b/Ix/MultiStark/Aggregate.lean
new file mode 100644
index 000000000..23c46119a
--- /dev/null
+++ b/Ix/MultiStark/Aggregate.lean
@@ -0,0 +1,742 @@
+module
+public import Ix.Aiur.Meta
+public import Ix.IxVM.Blake3
+public import Ix.MultiStark.Verifier
+
+/-!
+# Binary recursive aggregation (aggregate-first)
+
+The mode-1 join from `plans/aggregate-first-pipeline.md` §6: verify two proofs
+of the recursion system, pin their entrypoints and transitive allowed-vk
+identity, decode their `CheckEnv` statements, re-open the canonical address
+sets behind their roots, and emit
+
+`subjects = subjects_L ∪ subjects_R`
+
+`assumptions = (assumptions_L ∪ assumptions_R) ∖ subjects`.
+
+`join_two_structural` is the mode-2 variant for large upper levels. It commits
+to the subject forest structurally (`nodeHash(leftRoot, rightRoot)`) and proves
+assumption discharge with per-candidate Merkle paths, avoiding a full subject
+tree re-open and canonical re-root at every upper node.
+
+All address-list operations use bytewise address comparison. Pointer identity
+is never used as set equality: Aiur memory constrains pointers to be unique,
+not stored values to be globally deduplicated.
+-/
+
+public section
+
+namespace MultiStark
+
+def aggregate := ⟦
+  enum JoinNextAssumption {
+    Done,
+    More(Addr, List‹Addr›, List‹Addr›)
+  }
+
+  /- ## Small strict byte readers
+
+  The join only decodes fixed-width digests, u64 function indices, and the
+  single-byte `CheckEnv` tag.  Keeping these readers local avoids pulling the
+  full IxVM Ixon decoder (and all of its kernel-only types) into the recursion
+  system.
+  -/
+
+  fn join_read_byte(stream: ByteStream) -> (U8, ByteStream) {
+    let ListNode.Cons(byte, rest) = load(stream);
+    (byte, rest)
+  }
+
+  fn join_read_address(stream: ByteStream) -> (Addr, ByteStream) {
+    let ListNode.Cons(b0, s) = load(stream);
+    let ListNode.Cons(b1, s) = load(s);
+    let ListNode.Cons(b2, s) = load(s);
+    let ListNode.Cons(b3, s) = load(s);
+    let ListNode.Cons(b4, s) = load(s);
+    let ListNode.Cons(b5, s) = load(s);
+    let ListNode.Cons(b6, s) = load(s);
+    let ListNode.Cons(b7, s) = load(s);
+    let ListNode.Cons(b8, s) = load(s);
+    let ListNode.Cons(b9, s) = load(s);
+    let ListNode.Cons(b10, s) = load(s);
+    let ListNode.Cons(b11, s) = load(s);
+    let ListNode.Cons(b12, s) = load(s);
+    let ListNode.Cons(b13, s) = load(s);
+    let ListNode.Cons(b14, s) = load(s);
+    let ListNode.Cons(b15, s) = load(s);
+    let ListNode.Cons(b16, s) = load(s);
+    let ListNode.Cons(b17, s) = load(s);
+    let ListNode.Cons(b18, s) = load(s);
+    let ListNode.Cons(b19, s) = load(s);
+    let ListNode.Cons(b20, s) = load(s);
+    let ListNode.Cons(b21, s) = load(s);
+    let ListNode.Cons(b22, s) = load(s);
+    let ListNode.Cons(b23, s) = load(s);
+    let ListNode.Cons(b24, s) = load(s);
+    let ListNode.Cons(b25, s) = load(s);
+    let ListNode.Cons(b26, s) = load(s);
+    let ListNode.Cons(b27, s) = load(s);
+    let ListNode.Cons(b28, s) = load(s);
+    let ListNode.Cons(b29, s) = load(s);
+    let ListNode.Cons(b30, s) = load(s);
+    let ListNode.Cons(b31, s) = load(s);
+    (store([b0, b1, b2, b3, b4, b5, b6, b7,
+            b8, b9, b10, b11, b12, b13, b14, b15,
+            b16, b17, b18, b19, b20, b21, b22, b23,
+            b24, b25, b26, b27, b28, b29, b30, b31]), s)
+  }
+
+  fn join_put_address(addr: Addr, rest: ByteStream) -> ByteStream {
+    let a = load(addr);
+    let s31 = store(ListNode.Cons(a[31], rest));
+    let s30 = store(ListNode.Cons(a[30], s31));
+    let s29 = store(ListNode.Cons(a[29], s30));
+    let s28 = store(ListNode.Cons(a[28], s29));
+    let s27 = store(ListNode.Cons(a[27], s28));
+    let s26 = store(ListNode.Cons(a[26], s27));
+    let s25 = store(ListNode.Cons(a[25], s26));
+    let s24 = store(ListNode.Cons(a[24], s25));
+    let s23 = store(ListNode.Cons(a[23], s24));
+    let s22 = store(ListNode.Cons(a[22], s23));
+    let s21 = store(ListNode.Cons(a[21], s22));
+    let s20 = store(ListNode.Cons(a[20], s21));
+    let s19 = store(ListNode.Cons(a[19], s20));
+    let s18 = store(ListNode.Cons(a[18], s19));
+    let s17 = store(ListNode.Cons(a[17], s18));
+    let s16 = store(ListNode.Cons(a[16], s17));
+    let s15 = store(ListNode.Cons(a[15], s16));
+    let s14 = store(ListNode.Cons(a[14], s15));
+    let s13 = store(ListNode.Cons(a[13], s14));
+    let s12 = store(ListNode.Cons(a[12], s13));
+    let s11 = store(ListNode.Cons(a[11], s12));
+    let s10 = store(ListNode.Cons(a[10], s11));
+    let s9 = store(ListNode.Cons(a[9], s10));
+    let s8 = store(ListNode.Cons(a[8], s9));
+    let s7 = store(ListNode.Cons(a[7], s8));
+    let s6 = store(ListNode.Cons(a[6], s7));
+    let s5 = store(ListNode.Cons(a[5], s6));
+    let s4 = store(ListNode.Cons(a[4], s5));
+    let s3 = store(ListNode.Cons(a[3], s4));
+    let s2 = store(ListNode.Cons(a[2], s3));
+    let s1 = store(ListNode.Cons(a[1], s2));
+    store(ListNode.Cons(a[0], s1))
+  }
+
+  fn join_pack_address(addr: Addr) -> [G; 8] {
+    let a = load(addr);
+    [@b3_pack_w([a[0], a[1], a[2], a[3]]),
+     @b3_pack_w([a[4], a[5], a[6], a[7]]),
+     @b3_pack_w([a[8], a[9], a[10], a[11]]),
+     @b3_pack_w([a[12], a[13], a[14], a[15]]),
+     @b3_pack_w([a[16], a[17], a[18], a[19]]),
+     @b3_pack_w([a[20], a[21], a[22], a[23]]),
+     @b3_pack_w([a[24], a[25], a[26], a[27]]),
+     @b3_pack_w([a[28], a[29], a[30], a[31]])]
+  }
+
+  -- `Ix.Merkle.nodeHash`: Blake3 of `0x01 ‖ left ‖ right`.
+  fn join_node_hash(left: Addr, right: Addr) -> Addr {
+    let tail = join_put_address(left,
+      join_put_address(right, store(ListNode.Nil)));
+    bytes_to_addr(store(ListNode.Cons(1u8, tail)))
+  }
+
+  -- `Ix.Merkle.leafHash`: Blake3 of `0x00 ‖ address`.
+  fn join_leaf_hash(addr: Addr) -> Addr {
+    let tail = join_put_address(addr, store(ListNode.Nil));
+    bytes_to_addr(store(ListNode.Cons(0u8, tail)))
+  }
+
+  fn join_pack_be4(a: U8, b: U8, c: U8, d: U8) -> G {
+    ((to_field(a) * 256 + to_field(b)) * 256 + to_field(c)) * 256
+      + to_field(d)
+  }
+
+  -- Byte-lexicographic address order: 0 = less, 1 = equal, 2 = greater.
+  -- Four-byte big-endian words stay below 2^32, so native field equality and
+  -- `u32_less_than` are exact.
+  fn join_address_order(a: Addr, b: Addr) -> G {
+    let av = load(a);
+    let bv = load(b);
+    let aw0 = @join_pack_be4(av[0], av[1], av[2], av[3]);
+    let bw0 = @join_pack_be4(bv[0], bv[1], bv[2], bv[3]);
+    match aw0 - bw0 {
+      0 =>
+        let aw1 = @join_pack_be4(av[4], av[5], av[6], av[7]);
+        let bw1 = @join_pack_be4(bv[4], bv[5], bv[6], bv[7]);
+        match aw1 - bw1 {
+          0 =>
+            let aw2 = @join_pack_be4(av[8], av[9], av[10], av[11]);
+            let bw2 = @join_pack_be4(bv[8], bv[9], bv[10], bv[11]);
+            match aw2 - bw2 {
+              0 =>
+                let aw3 = @join_pack_be4(av[12], av[13], av[14], av[15]);
+                let bw3 = @join_pack_be4(bv[12], bv[13], bv[14], bv[15]);
+                match aw3 - bw3 {
+                  0 =>
+                    let aw4 = @join_pack_be4(av[16], av[17], av[18], av[19]);
+                    let bw4 = @join_pack_be4(bv[16], bv[17], bv[18], bv[19]);
+                    match aw4 - bw4 {
+                      0 =>
+                        let aw5 = @join_pack_be4(av[20], av[21], av[22], av[23]);
+                        let bw5 = @join_pack_be4(bv[20], bv[21], bv[22], bv[23]);
+                        match aw5 - bw5 {
+                          0 =>
+                            let aw6 = @join_pack_be4(av[24], av[25], av[26], av[27]);
+                            let bw6 = @join_pack_be4(bv[24], bv[25], bv[26], bv[27]);
+                            match aw6 - bw6 {
+                              0 =>
+                                let aw7 = @join_pack_be4(av[28], av[29], av[30], av[31]);
+                                let bw7 = @join_pack_be4(bv[28], bv[29], bv[30], bv[31]);
+                                match aw7 - bw7 {
+                                  0 => 1,
+                                  _ => match u32_less_than(aw7, bw7) { 1 => 0, _ => 2, },
+                                },
+                              _ => match u32_less_than(aw6, bw6) { 1 => 0, _ => 2, },
+                            },
+                          _ => match u32_less_than(aw5, bw5) { 1 => 0, _ => 2, },
+                        },
+                      _ => match u32_less_than(aw4, bw4) { 1 => 0, _ => 2, },
+                    },
+                  _ => match u32_less_than(aw3, bw3) { 1 => 0, _ => 2, },
+                },
+              _ => match u32_less_than(aw2, bw2) { 1 => 0, _ => 2, },
+            },
+          _ => match u32_less_than(aw1, bw1) { 1 => 0, _ => 2, },
+        },
+      _ => match u32_less_than(aw0, bw0) { 1 => 0, _ => 2, },
+    }
+  }
+
+  fn join_assert_strict_sorted(leaves: List‹Addr›) {
+    match load(leaves) {
+      ListNode.Nil => (),
+      ListNode.Cons(a, rest) =>
+        match load(rest) {
+          ListNode.Nil => (),
+          ListNode.Cons(b, _) =>
+            assert_eq!(join_address_order(a, b), 0,
+              "join: tree leaves are not strictly sorted");
+            join_assert_strict_sorted(rest),
+        },
+    }
+  }
+
+  -- Parse an `AssumptionTree` body into its in-order real leaves. Padding is
+  -- omitted. The serialized shape is advice; canonical-root recomputation
+  -- below binds the resulting sorted leaf set to the requested root.
+  fn join_parse_tree_body(stream: ByteStream) -> (List‹Addr›, ByteStream) {
+    let (tag, rest) = join_read_byte(stream);
+    match tag {
+      0 =>
+        let (addr, stop) = join_read_address(rest);
+        (store(ListNode.Cons(addr, store(ListNode.Nil))), stop),
+      1 => (store(ListNode.Nil), rest),
+      2 =>
+        let (left, s2) = join_parse_tree_body(rest);
+        let (right, stop) = join_parse_tree_body(s2);
+        (list_concat(left, right), stop),
+    }
+  }
+
+  fn join_leaf_hashes(leaves: List‹Addr›) -> List‹Addr› {
+    match load(leaves) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(addr, rest) =>
+        store(ListNode.Cons(join_leaf_hash(addr), join_leaf_hashes(rest))),
+    }
+  }
+
+  -- One canonical Merkle reduction level. An odd last node is paired with
+  -- the zero-address padding sentinel.
+  fn join_pair_hashes(nodes: List‹Addr›) -> List‹Addr› {
+    match load(nodes) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(left, rest) =>
+        match load(rest) {
+          ListNode.Nil =>
+            let zero = store([0u8; 32]);
+            store(ListNode.Cons(join_node_hash(left, zero), store(ListNode.Nil))),
+          ListNode.Cons(right, tail) =>
+            store(ListNode.Cons(join_node_hash(left, right), join_pair_hashes(tail))),
+        },
+    }
+  }
+
+  fn join_reduce_hashes(nodes: List‹Addr›) -> Addr {
+    let ListNode.Cons(root, rest) = load(nodes);
+    match load(rest) {
+      ListNode.Nil => root,
+      _ => join_reduce_hashes(join_pair_hashes(nodes)),
+    }
+  }
+
+  fn join_canonical_root(leaves: List‹Addr›) -> Addr {
+    join_reduce_hashes(join_leaf_hashes(leaves))
+  }
+
+  fn join_load_canonical_tree(root: Addr) -> List‹Addr› {
+    let raw = load(root);
+    let (idx, len) = io_get_info(5, raw);
+    let bytes = #read_byte_stream(5, idx, len);
+    let (tag, body) = join_read_byte(bytes);
+    assert_eq!(tag, 0xE2u8, "join: tree has the wrong Ixon tag");
+    let (leaves, stop) = join_parse_tree_body(body);
+    assert_eq!(load(stop), ListNode.Nil,
+      "join: trailing bytes after AssumptionTree");
+    assert_eq!(list_is_empty(leaves), 0,
+      "join: a present tree must contain at least one leaf");
+    join_assert_strict_sorted(leaves);
+    let expected = join_canonical_root(leaves);
+    assert_eq!(address_eq(expected, root), 1,
+      "join: tree leaves do not reproduce the canonical root");
+    leaves
+  }
+
+  fn join_load_optional_tree(root: Option‹Addr›) -> List‹Addr› {
+    match root {
+      Option.None => store(ListNode.Nil),
+      Option.Some(addr) => join_load_canonical_tree(addr),
+    }
+  }
+
+  fn join_assert_same_list(left: List‹Addr›, right: List‹Addr›) {
+    match (load(left), load(right)) {
+      (ListNode.Nil, ListNode.Nil) => (),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        assert_eq!(address_eq(a, b), 1, "join: set element mismatch");
+        join_assert_same_list(ar, br),
+    }
+  }
+
+  -- Assert `output` is the sorted, deduplicated union of two sorted unique
+  -- inputs. The merge is linear in the number of leaves.
+  fn join_assert_union(left: List‹Addr›, right: List‹Addr›,
+      output: List‹Addr›) {
+    match (load(left), load(right)) {
+      (ListNode.Nil, _) => join_assert_same_list(right, output),
+      (_, ListNode.Nil) => join_assert_same_list(left, output),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        let ListNode.Cons(o, or) = load(output);
+        match join_address_order(a, b) {
+          0 =>
+            assert_eq!(address_eq(a, o), 1, "join: subject union mismatch");
+            join_assert_union(ar, right, or),
+          1 =>
+            assert_eq!(address_eq(a, o), 1, "join: subject union mismatch");
+            join_assert_union(ar, br, or),
+          _ =>
+            assert_eq!(address_eq(b, o), 1, "join: subject union mismatch");
+            join_assert_union(left, br, or),
+        },
+    }
+  }
+
+  -- Select the next unique value from the union of two sorted assumption
+  -- lists, returning the unconsumed tails.
+  fn join_next_assumption(left: List‹Addr›, right: List‹Addr›)
+      -> JoinNextAssumption {
+    match (load(left), load(right)) {
+      (ListNode.Nil, ListNode.Nil) => JoinNextAssumption.Done,
+      (ListNode.Cons(a, ar), ListNode.Nil) =>
+        JoinNextAssumption.More(a, ar, right),
+      (ListNode.Nil, ListNode.Cons(b, br)) =>
+        JoinNextAssumption.More(b, left, br),
+      (ListNode.Cons(a, ar), ListNode.Cons(b, br)) =>
+        match join_address_order(a, b) {
+          0 => JoinNextAssumption.More(a, ar, right),
+          1 => JoinNextAssumption.More(a, ar, br),
+          _ => JoinNextAssumption.More(b, left, br),
+        },
+    }
+  }
+
+  -- Find `target` in a sorted subject list, discarding subject values below it
+  -- and returning the suffix useful for the next (strictly larger) target.
+  fn join_seek_subject(target: Addr, subjects: List‹Addr›)
+      -> (G, List‹Addr›) {
+    match load(subjects) {
+      ListNode.Nil => (0, subjects),
+      ListNode.Cons(subject, rest) =>
+        match join_address_order(subject, target) {
+          0 => join_seek_subject(target, rest),
+          1 => (1, rest),
+          _ => (0, subjects),
+        },
+    }
+  }
+
+  -- Assert `output = (left ∪ right) ∖ subjects`, all lists sorted and
+  -- duplicate-free. Subject scan state is threaded so the check is linear.
+  fn join_assert_difference(left: List‹Addr›, right: List‹Addr›,
+      subjects: List‹Addr›, output: List‹Addr›) {
+    match join_next_assumption(left, right) {
+      JoinNextAssumption.Done =>
+        assert_eq!(load(output), ListNode.Nil,
+          "join: output has an extra assumption");
+        (),
+      JoinNextAssumption.More(candidate, left_rest, right_rest) =>
+        let (discharged, subject_rest) = join_seek_subject(candidate, subjects);
+        match discharged {
+          1 => join_assert_difference(left_rest, right_rest, subject_rest, output),
+          _ =>
+            let ListNode.Cons(actual, output_rest) = load(output);
+            assert_eq!(address_eq(candidate, actual), 1,
+              "join: outstanding assumption mismatch");
+            join_assert_difference(left_rest, right_rest, subject_rest, output_rest),
+        },
+    }
+  }
+
+  /- ## Structural assumption discharge
+
+  Structural joins do not open their subject tree. Instead, channel 6 carries
+  one choice for every unique input-assumption candidate, keyed by the raw
+  candidate address. A carried candidate must occur next in the canonical
+  output-assumption list; a discharged candidate must supply a valid Merkle
+  path into the one-hash structural output root.
+  -/
+
+  fn join_fold_path(hash: Addr, remaining: G, stream: ByteStream)
+      -> (Addr, ByteStream) {
+    match remaining {
+      0 => (hash, stream),
+      _ =>
+        let (side, s1) = join_read_byte(stream);
+        assert_eq!(u8_less_than(side, 2u8), 1,
+          "structural join: path side must be 0 or 1");
+        let (sibling, s2) = join_read_address(s1);
+        let parent = match side {
+          0 => join_node_hash(sibling, hash),
+          _ => join_node_hash(hash, sibling),
+        };
+        join_fold_path(parent, remaining - 1, s2),
+    }
+  }
+
+  -- Return 1 when `candidate` is discharged by a path into `root`, or 0
+  -- when it is explicitly carried. The payload is strict:
+  --   carried:    0
+  --   discharged: 1 || count:u8 || (side:u8 || sibling:32)*
+  fn join_discharge_choice(candidate: Addr, root: Addr) -> G {
+    let (idx, len) = io_get_info(6, load(candidate));
+    let bytes = #read_byte_stream(6, idx, len);
+    let (choice, rest) = join_read_byte(bytes);
+    assert_eq!(u8_less_than(choice, 2u8), 1,
+      "structural join: discharge choice must be 0 or 1");
+    match choice {
+      0 =>
+        assert_eq!(load(rest), ListNode.Nil,
+          "structural join: carried choice has trailing bytes");
+        0,
+      _ =>
+        let (count, path) = join_read_byte(rest);
+        assert_eq!(u8_less_than(count, 65u8), 1,
+          "structural join: Merkle path exceeds 64 steps");
+        let (actual, stop) = join_fold_path(join_leaf_hash(candidate),
+          to_field(count), path);
+        assert_eq!(load(stop), ListNode.Nil,
+          "structural join: trailing bytes after Merkle path");
+        assert_eq!(address_eq(actual, root), 1,
+          "structural join: assumption path does not reach subject root");
+        1,
+    }
+  }
+
+  -- Every unique candidate from `left ∪ right` is either discharged by a
+  -- membership path or consumed from the strictly-sorted output list. A
+  -- candidate may be over-carried even when a path exists; that only weakens
+  -- the output claim and cannot pass an unconditional root check.
+  fn join_assert_structural_difference(left: List‹Addr›, right: List‹Addr›,
+      subject_root: Addr, output: List‹Addr›) {
+    match join_next_assumption(left, right) {
+      JoinNextAssumption.Done =>
+        assert_eq!(load(output), ListNode.Nil,
+          "structural join: output has an extra assumption");
+        (),
+      JoinNextAssumption.More(candidate, left_rest, right_rest) =>
+        match join_discharge_choice(candidate, subject_root) {
+          1 => join_assert_structural_difference(left_rest, right_rest,
+            subject_root, output),
+          _ =>
+            let ListNode.Cons(actual, output_rest) = load(output);
+            assert_eq!(address_eq(candidate, actual), 1,
+              "structural join: outstanding assumption mismatch");
+            join_assert_structural_difference(left_rest, right_rest,
+              subject_root, output_rest),
+        },
+    }
+  }
+
+  fn join_get_opt_address(stream: ByteStream) -> (Option‹Addr›, ByteStream) {
+    let (tag, rest) = join_read_byte(stream);
+    match tag {
+      0 => (Option.None, rest),
+      1 =>
+        let (addr, stop) = join_read_address(rest);
+        (Option.Some(addr), stop),
+    }
+  }
+
+  -- Strictly decode one complete `Claim::CheckEnv` byte string.
+  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 (root, s2) = join_read_address(s);
+    let (assumptions, stop) = join_get_opt_address(s2);
+    assert_eq!(load(stop), ListNode.Nil,
+      "join: trailing bytes after CheckEnv claim");
+    (root, assumptions)
+  }
+
+  /- ## Digest-bound advice and outer-claim decoding -/
+
+  fn join_load_preimage(digest: [G; 8]) -> ByteStream {
+    let (idx, len) = io_get_info(4, digest);
+    let bytes = #read_byte_stream(4, idx, len);
+    assert_eq!(@b3_pack(@blake3(bytes)), digest,
+      "join: claim preimage digest mismatch");
+    bytes
+  }
+
+  fn join_claim_field(claim: List‹U64›, index: G) -> G {
+    @gl_val(list_lookup(claim, index))
+  }
+
+  fn join_claim_digest(claim: List‹U64›, start: G) -> [G; 8] {
+    [join_claim_field(claim, start),
+     join_claim_field(claim, start + 1),
+     join_claim_field(claim, start + 2),
+     join_claim_field(claim, start + 3),
+     join_claim_field(claim, start + 4),
+     join_claim_field(claim, start + 5),
+     join_claim_field(claim, start + 6),
+     join_claim_field(claim, start + 7)]
+  }
+
+  fn join_assert_digest(actual: [G; 8], expected: [G; 8]) {
+    assert_eq!(actual[0], expected[0]);
+    assert_eq!(actual[1], expected[1]);
+    assert_eq!(actual[2], expected[2]);
+    assert_eq!(actual[3], expected[3]);
+    assert_eq!(actual[4], expected[4]);
+    assert_eq!(actual[5], expected[5]);
+    assert_eq!(actual[6], expected[6]);
+    assert_eq!(actual[7], expected[7]);
+    ()
+  }
+
+  fn join_only_claim(claims: List‹List‹U64››) -> List‹U64› {
+    let ListNode.Cons(claim, rest) = load(claims);
+    assert_eq!(load(rest), ListNode.Nil,
+      "join: child proof must expose exactly one claim");
+    claim
+  }
+
+  -- Verify one recursive child against the already-bound recursion system.
+  -- Child claims need no standalone public digest: the verified proof's lookup
+  -- accumulator and Fiat-Shamir transcript bind `cbytes` directly.
+  fn join_verify_child(sys: Sys, key: G) -> List‹List‹U64›› {
+    let (idx, len) = io_get_info(0, [key]);
+    let (proof, stop) = @read_proof(idx);
+    assert_eq!(stop, idx + len);
+    let (cidx, clen) = io_get_info(2, [key]);
+    let cbytes = #read_byte_stream(2, cidx, clen);
+    let (claims, crest) = @read_claims(cbytes);
+    assert_eq!(load(crest), ListNode.Nil);
+    assert_eq!(@verify(proof), 1);
+    assert_eq!(@ood_verify(sys, proof, claims, cbytes), 1);
+    claims
+  }
+
+  -- Open the IxVM claim nested under a lift's claims digest.
+  fn join_decode_lift_claim(outer: List‹U64›, verify_claim_idx: G)
+      -> (Addr, Option‹Addr›) {
+    let claims_digest = join_claim_digest(outer, 10);
+    let claims_bytes = join_load_preimage(claims_digest);
+    let (inner_claims, rest) = @read_claims(claims_bytes);
+    assert_eq!(load(rest), ListNode.Nil);
+    let inner = join_only_claim(inner_claims);
+    assert_eq!(list_length(inner), 10,
+      "join: IxVM lift must expose a 10-word verify_claim claim");
+    assert_eq!(join_claim_field(inner, 0), 0,
+      "join: IxVM child has the wrong claim channel");
+    assert_eq!(join_claim_field(inner, 1), verify_claim_idx,
+      "join: IxVM child has the wrong entrypoint");
+    let check_env_digest = join_claim_digest(inner, 2);
+    join_parse_check_env(join_load_preimage(check_env_digest))
+  }
+
+  -- Decode a verified child as either a lift or a transitive flat/structural
+  -- join. Function
+  -- indices live in the digest-bound allowed blob because Source programs have
+  -- no primitive for materializing their compiler-assigned numeric index.
+  fn join_decode_child(outer_claims: List‹List‹U64››,
+      ixvm_vk_digest: [G; 8], allowed_digest: [G; 8],
+      verify_claim_idx: G, lift_idx: G, join_idx: G, struct_join_idx: G)
+      -> (Addr, Option‹Addr›) {
+    let outer = join_only_claim(outer_claims);
+    assert_eq!(list_length(outer), 18,
+      "join: recursive child claim must contain 16 public inputs");
+    assert_eq!(join_claim_field(outer, 0), 0,
+      "join: recursive child has the wrong claim channel");
+    let child_idx = join_claim_field(outer, 1);
+    match eq_zero(child_idx - lift_idx) {
+      1 =>
+        join_assert_digest(join_claim_digest(outer, 2), ixvm_vk_digest);
+        join_decode_lift_claim(outer, verify_claim_idx),
+      _ =>
+        match eq_zero(child_idx - join_idx) {
+          1 => (),
+          _ =>
+            assert_eq!(child_idx, struct_join_idx,
+              "join: child is neither lift, flat join, nor structural join");
+            (),
+        };
+        join_assert_digest(join_claim_digest(outer, 2), allowed_digest);
+        let output_digest = join_claim_digest(outer, 10);
+        join_parse_check_env(join_load_preimage(output_digest)),
+    }
+  }
+
+  /- ## Canonical set-discharge join -/
+
+  -- Verify two lift/join proofs and emit the canonical union/difference of their
+  -- `CheckEnv` statements. Public input is
+  -- `blake3(allowed_blob) ‖ blake3(output_claim_bytes)`, packed four bytes per
+  -- Goldilocks element.
+  pub fn join_two(allowed_digest: [G; 8], out_claim_digest: [G; 8]) {
+    -- Allowed blob:
+    --   ixvm_vk_digest(32) ‖ verify_claim_idx(u64 LE) ‖
+    --   recursion_vk_digest(32) ‖ lift_idx(u64 LE) ‖ join_idx(u64 LE) ‖
+    --   struct_join_idx(u64 LE).
+    let (aidx, alen) = io_get_info(3, [0]);
+    assert_eq!(alen, 96,
+      "join: allowed blob must be exactly 96 bytes");
+    let allowed_bytes = #read_byte_stream(3, aidx, alen);
+    assert_eq!(@b3_pack(@blake3(allowed_bytes)), allowed_digest,
+      "join: allowed blob digest mismatch");
+    let (ixvm_digest_addr, as1) = join_read_address(allowed_bytes);
+    let (verify_idx_limb, as2) = @read_u64(as1);
+    let (rec_digest_addr, as3) = join_read_address(as2);
+    let (lift_idx_limb, as4) = @read_u64(as3);
+    let (join_idx_limb, as5) = @read_u64(as4);
+    let (struct_join_idx_limb, astop) = @read_u64(as5);
+    assert_eq!(load(astop), ListNode.Nil,
+      "join: allowed blob must be exactly 96 bytes");
+    let ixvm_vk_digest = join_pack_address(ixvm_digest_addr);
+    let rec_vk_digest = join_pack_address(rec_digest_addr);
+    let verify_claim_idx = flatten_u64(verify_idx_limb);
+    let lift_idx = flatten_u64(lift_idx_limb);
+    let join_idx = flatten_u64(join_idx_limb);
+    let struct_join_idx = flatten_u64(struct_join_idx_limb);
+
+    -- Deserialize and bind this recursion system's vk once; both children
+    -- verify against the same system.
+    let (sidx, slen) = io_get_info(1, [0]);
+    let sbytes = #read_byte_stream(1, sidx, slen);
+    assert_eq!(@b3_pack(@blake3(sbytes)), rec_vk_digest,
+      "join: recursion vk digest mismatch");
+    let (sys, srest) = @read_system(sbytes);
+    assert_eq!(load(srest), ListNode.Nil);
+
+    let left_claims = join_verify_child(sys, 0);
+    let right_claims = join_verify_child(sys, 1);
+    let (left_root, left_asm) = join_decode_child(left_claims,
+      ixvm_vk_digest, allowed_digest, verify_claim_idx, lift_idx, join_idx,
+      struct_join_idx);
+    let (right_root, right_asm) = join_decode_child(right_claims,
+      ixvm_vk_digest, allowed_digest, verify_claim_idx, lift_idx, join_idx,
+      struct_join_idx);
+
+    -- Bind and decode the current join's output claim.
+    let (oidx, olen) = io_get_info(2, [2]);
+    let output_bytes = #read_byte_stream(2, oidx, olen);
+    assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest,
+      "join: output claim digest mismatch");
+    let (output_root, output_asm) = join_parse_check_env(output_bytes);
+
+    let left_subjects = join_load_canonical_tree(left_root);
+    let right_subjects = join_load_canonical_tree(right_root);
+    let left_assumptions = join_load_optional_tree(left_asm);
+    let right_assumptions = join_load_optional_tree(right_asm);
+    let output_subjects = join_load_canonical_tree(output_root);
+    let output_assumptions = join_load_optional_tree(output_asm);
+
+    join_assert_union(left_subjects, right_subjects, output_subjects);
+    join_assert_difference(left_assumptions, right_assumptions,
+      output_subjects, output_assumptions);
+    ()
+  }
+
+  /- ## Structural root-of-roots join -/
+
+  -- Verify the same child forms as `join_two`, but commit to subjects with one
+  -- free-form node hash and discharge assumptions through channel-6 Merkle
+  -- paths. Assumption trees remain canonical and are the only trees loaded on
+  -- channel 5.
+  pub fn join_two_structural(allowed_digest: [G; 8], out_claim_digest: [G; 8]) {
+    -- Allowed blob v2:
+    --   ixvm_vk_digest(32) ‖ verify_claim_idx(u64 LE) ‖
+    --   recursion_vk_digest(32) ‖ lift_idx(u64 LE) ‖ join_idx(u64 LE) ‖
+    --   struct_join_idx(u64 LE).
+    let (aidx, alen) = io_get_info(3, [0]);
+    assert_eq!(alen, 96,
+      "structural join: allowed blob must be exactly 96 bytes");
+    let allowed_bytes = #read_byte_stream(3, aidx, alen);
+    assert_eq!(@b3_pack(@blake3(allowed_bytes)), allowed_digest,
+      "structural join: allowed blob digest mismatch");
+    let (ixvm_digest_addr, as1) = join_read_address(allowed_bytes);
+    let (verify_idx_limb, as2) = @read_u64(as1);
+    let (rec_digest_addr, as3) = join_read_address(as2);
+    let (lift_idx_limb, as4) = @read_u64(as3);
+    let (join_idx_limb, as5) = @read_u64(as4);
+    let (struct_join_idx_limb, astop) = @read_u64(as5);
+    assert_eq!(load(astop), ListNode.Nil,
+      "structural join: allowed blob must be exactly 96 bytes");
+    let ixvm_vk_digest = join_pack_address(ixvm_digest_addr);
+    let rec_vk_digest = join_pack_address(rec_digest_addr);
+    let verify_claim_idx = flatten_u64(verify_idx_limb);
+    let lift_idx = flatten_u64(lift_idx_limb);
+    let join_idx = flatten_u64(join_idx_limb);
+    let struct_join_idx = flatten_u64(struct_join_idx_limb);
+
+    let (sidx, slen) = io_get_info(1, [0]);
+    let sbytes = #read_byte_stream(1, sidx, slen);
+    assert_eq!(@b3_pack(@blake3(sbytes)), rec_vk_digest,
+      "structural join: recursion vk digest mismatch");
+    let (sys, srest) = @read_system(sbytes);
+    assert_eq!(load(srest), ListNode.Nil);
+
+    let left_claims = join_verify_child(sys, 0);
+    let right_claims = join_verify_child(sys, 1);
+    let (left_root, left_asm) = join_decode_child(left_claims,
+      ixvm_vk_digest, allowed_digest, verify_claim_idx, lift_idx, join_idx,
+      struct_join_idx);
+    let (right_root, right_asm) = join_decode_child(right_claims,
+      ixvm_vk_digest, allowed_digest, verify_claim_idx, lift_idx, join_idx,
+      struct_join_idx);
+
+    let (oidx, olen) = io_get_info(2, [2]);
+    let output_bytes = #read_byte_stream(2, oidx, olen);
+    assert_eq!(@b3_pack(@blake3(output_bytes)), out_claim_digest,
+      "structural join: output claim digest mismatch");
+    let (output_root, output_asm) = join_parse_check_env(output_bytes);
+
+    let expected_root = join_node_hash(left_root, right_root);
+    assert_eq!(address_eq(output_root, expected_root), 1,
+      "structural join: output subject root is not nodeHash(left, right)");
+
+    let left_assumptions = join_load_optional_tree(left_asm);
+    let right_assumptions = join_load_optional_tree(right_asm);
+    let output_assumptions = join_load_optional_tree(output_asm);
+    join_assert_structural_difference(left_assumptions, right_assumptions,
+      output_root, output_assumptions);
+    ()
+  }
+⟧
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Deserialize.lean b/Ix/MultiStark/Deserialize.lean
index 96fcb9cbf..2a808d36d 100644
--- a/Ix/MultiStark/Deserialize.lean
+++ b/Ix/MultiStark/Deserialize.lean
@@ -79,34 +79,37 @@ def deserialize := ⟦
     Mk(MerkleCap, MerkleCap, MerkleCap)
   }
 
-  -- `BatchOpening<Val, Mmcs>`: per-round input opening of a FRI query.
-  --   opened_values : Vec<Vec<Val>>   (one row of base-field values per matrix)
-  --   opening_proof : Vec<Digest>     (Merkle authentication path)
-  enum BatchOpening {
-    Mk(List‹List‹U64››, List‹DigestP›)
+  -- One input commitment opened at all query indices with a shared pruned
+  -- Merkle frontier. `opened_values[q][m]` is query q's row of matrix m.
+  enum BatchMultiOpening {
+    Mk(List‹List‹List‹U64›››, List‹DigestP›)
   }
 
   -- `CommitPhaseProofStep<ExtVal, ExtMmcs>`: one folding step of a FRI query.
   --   log_arity      : u8
   --   sibling_values : Vec<Ext>  (arity - 1 siblings)
   --   opening_proof  : Vec<Digest>
-  enum CommitPhaseProofStep {
-    Mk(U8, List‹Ext›, List‹DigestP›)
+  enum CommitPhaseMultiStep {
+    Mk(U8, List‹List‹Ext››, List‹DigestP›)
   }
 
-  -- `QueryProof<ExtVal, ExtMmcs, Vec<BatchOpening<Val, Mmcs>>>`.
-  enum QueryProof {
-    Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›)
-  }
+  -- Per-query views derived in-circuit from the native batch openings. They
+  -- retain the existing FRI arithmetic organization; authentication is done
+  -- once per native multiproof before that arithmetic runs.
+  enum BatchOpening { Mk(List‹List‹U64››) }
+  enum CommitPhaseProofStep { Mk(U8, List‹Ext›) }
+  enum QueryProof { Mk(List‹BatchOpening›, List‹CommitPhaseProofStep›) }
 
   -- `PcsProof = FriProof<ExtVal, ExtMmcs, Witness = Val, ..>`.
   --   commit_phase_commits : Vec<MerkleCap>
   --   commit_pow_witnesses : Vec<Val>
-  --   query_proofs         : Vec<QueryProof>
+  --   input_openings       : Vec<BatchMultiOpening>
+  --   commit_phase_openings: Vec<CommitPhaseMultiStep>
   --   final_poly           : Vec<Ext>
   --   query_pow_witness    : Val
   enum FriProof {
-    Mk(List‹MerkleCap›, List‹U64›, List‹QueryProof›, List‹Ext›, U64)
+    Mk(List‹MerkleCap›, List‹U64›, List‹BatchMultiOpening›,
+       List‹CommitPhaseMultiStep›, List‹Ext›, U64)
   }
 
   -- `Option<OpenedRound>` for `preprocessed_opened_values`. A dedicated
@@ -301,6 +304,20 @@ def deserialize := ⟦
     }
   }
 
+  fn read_u64_vec_vec_vec(i: G) -> (List‹List‹List‹U64›››, G) {
+    let (n, j) = read_count_at(i);
+    read_u64_vec_vec_vec_n(j, n)
+  }
+  fn read_u64_vec_vec_vec_n(i: G, n: G) -> (List‹List‹List‹U64›››, G) {
+    match n {
+      0 => (store(ListNode.Nil), i),
+      _ =>
+        let (x, j) = @read_u64_vec_vec(i);
+        let (rest, j2) = read_u64_vec_vec_vec_n(j, n - 1);
+        (store(ListNode.Cons(x, rest)), j2),
+    }
+  }
+
   -- `OpenedRound = Vec<Vec<Vec<Ext>>>`, built bottom-up from `read_ext_vec`.
   fn read_ext_vec_vec(i: G) -> (List‹List‹Ext››, G) {
     let (n, j) = read_count_at(i);
@@ -358,16 +375,16 @@ def deserialize := ⟦
     (Commitments.Mk(stage_1_trace, stage_2_trace, quotient_chunks), j2)
   }
 
-  fn read_batch_opening(i: G) -> (BatchOpening, G) {
-    let (opened_values, j0) = @read_u64_vec_vec(i);
+  fn read_batch_opening(i: G) -> (BatchMultiOpening, G) {
+    let (opened_values, j0) = @read_u64_vec_vec_vec(i);
     let (opening_proof, j1) = read_digest_vec_at(j0);
-    (BatchOpening.Mk(opened_values, opening_proof), j1)
+    (BatchMultiOpening.Mk(opened_values, opening_proof), j1)
   }
-  fn read_batch_opening_vec(i: G) -> (List‹BatchOpening›, G) {
+  fn read_batch_opening_vec(i: G) -> (List‹BatchMultiOpening›, G) {
     let (n, j) = read_count_at(i);
     read_batch_opening_vec_n(j, n)
   }
-  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchOpening›, G) {
+  fn read_batch_opening_vec_n(i: G, n: G) -> (List‹BatchMultiOpening›, G) {
     match n {
       0 => (store(ListNode.Nil), i),
       _ =>
@@ -377,17 +394,17 @@ def deserialize := ⟦
     }
   }
 
-  fn read_commit_phase_step(i: G) -> (CommitPhaseProofStep, G) {
+  fn read_commit_phase_step(i: G) -> (CommitPhaseMultiStep, G) {
     let (log_arity, j0) = #read_u8_at(i);
-    let (sibling_values, j1) = read_ext_vec(j0);
+    let (sibling_values, j1) = @read_ext_vec_vec(j0);
     let (opening_proof, j2) = read_digest_vec_at(j1);
-    (CommitPhaseProofStep.Mk(log_arity, sibling_values, opening_proof), j2)
+    (CommitPhaseMultiStep.Mk(log_arity, sibling_values, opening_proof), j2)
   }
-  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseProofStep›, G) {
+  fn read_commit_phase_step_vec(i: G) -> (List‹CommitPhaseMultiStep›, G) {
     let (n, j) = read_count_at(i);
     read_commit_phase_step_vec_n(j, n)
   }
-  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseProofStep›, G) {
+  fn read_commit_phase_step_vec_n(i: G, n: G) -> (List‹CommitPhaseMultiStep›, G) {
     match n {
       0 => (store(ListNode.Nil), i),
       _ =>
@@ -397,33 +414,15 @@ def deserialize := ⟦
     }
   }
 
-  fn read_query_proof(i: G) -> (QueryProof, G) {
-    let (input_proof, j0) = @read_batch_opening_vec(i);
-    let (commit_phase_openings, j1) = @read_commit_phase_step_vec(j0);
-    (QueryProof.Mk(input_proof, commit_phase_openings), j1)
-  }
-  fn read_query_proof_vec(i: G) -> (List‹QueryProof›, G) {
-    let (n, j) = read_count_at(i);
-    read_query_proof_vec_n(j, n)
-  }
-  fn read_query_proof_vec_n(i: G, n: G) -> (List‹QueryProof›, G) {
-    match n {
-      0 => (store(ListNode.Nil), i),
-      _ =>
-        let (x, j) = @read_query_proof(i);
-        let (rest, j2) = read_query_proof_vec_n(j, n - 1);
-        (store(ListNode.Cons(x, rest)), j2),
-    }
-  }
-
   fn read_fri_proof(i: G) -> (FriProof, G) {
     let (commit_phase_commits, j0) = @read_merkle_cap_vec(i);
     let (commit_pow_witnesses, j1) = read_u64_vec(j0);
-    let (query_proofs, j2) = @read_query_proof_vec(j1);
-    let (final_poly, j3) = read_ext_vec(j2);
-    let (query_pow_witness, j4) = #read_u64_at(j3);
-    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, query_proofs,
-                 final_poly, query_pow_witness), j4)
+    let (input_openings, j2) = @read_batch_opening_vec(j1);
+    let (commit_phase_openings, j3) = @read_commit_phase_step_vec(j2);
+    let (final_poly, j4) = read_ext_vec(j3);
+    let (query_pow_witness, j5) = #read_u64_at(j4);
+    (FriProof.Mk(commit_phase_commits, commit_pow_witnesses, input_openings,
+                 commit_phase_openings, final_poly, query_pow_witness), j5)
   }
 
   -- The activation bitmap: `Vec<bool>` on the wire (u64 count, then one
diff --git a/Ix/MultiStark/Host.lean b/Ix/MultiStark/Host.lean
new file mode 100644
index 000000000..28e278b9c
--- /dev/null
+++ b/Ix/MultiStark/Host.lean
@@ -0,0 +1,129 @@
+module
+public import Ix.AssumptionTree
+public import Ix.Claim
+public import Std.Data.HashSet
+
+/-!
+# Host-side aggregate-first statement folding
+
+The circuit rechecks all of this from serialized trees and Merkle paths. These
+helpers give the CLI one implementation for constructing flat and structural
+outputs plus their channel-5/channel-6 advice.
+-/
+
+public section
+
+namespace MultiStark
+
+/-- A `CheckEnv` statement together with the trees whose roots it commits to.
+Leaf and flat-join subject trees are canonical; structural joins use free-form
+root-of-roots subject trees. Assumption trees always remain canonical.
+`assumptions = none` is represented by no tree, never by an empty or
+padding-only serialization. -/
+structure CheckEnvTrees where
+  subjects : Ix.AssumptionTree
+  assumptions : Option Ix.AssumptionTree
+  deriving Repr
+
+namespace CheckEnvTrees
+
+def claim (statement : CheckEnvTrees) : Ix.Claim :=
+  .checkEnv statement.subjects.root (statement.assumptions.map (·.root))
+
+def subjectCount (statement : CheckEnvTrees) : Nat :=
+  statement.subjects.leaves.size
+
+private def canonicalizeAt (label : String) (expected : Address)
+    (tree : Ix.AssumptionTree) : Except String Ix.AssumptionTree := do
+  let some canonical := Ix.AssumptionTree.canonical tree.leaves
+    | throw s!"{label}: tree has no real leaves"
+  if canonical.root != expected then
+    throw s!"{label}: leaves do not reproduce claimed canonical root {expected}"
+  pure canonical
+
+/-- Recover and validate a host statement from a claim plus its content-
+addressed tree map. This is used when turning persisted shard proofs into lift
+slots: the wrapper's claim roots must match canonical trees reconstructed from
+the `.ixe` environment. -/
+def ofClaim (claim : Ix.Claim)
+    (trees : Std.HashMap Address Ix.AssumptionTree) : Except String CheckEnvTrees := do
+  let .checkEnv subjectRoot assumptionRoot? := claim
+    | throw "aggregate: expected a CheckEnv claim"
+  let some subjectTree := trees.get? subjectRoot
+    | throw s!"aggregate: missing subject tree {subjectRoot}"
+  let subjects ← canonicalizeAt "aggregate subjects" subjectRoot subjectTree
+  let assumptions ← match assumptionRoot? with
+    | none => pure none
+    | some assumptionRoot =>
+      let some assumptionTree := trees.get? assumptionRoot
+        | throw s!"aggregate: missing assumption tree {assumptionRoot}"
+      pure (some (← canonicalizeAt "aggregate assumptions"
+        assumptionRoot assumptionTree))
+  pure { subjects, assumptions }
+
+private def assumptionLeaves (statement : CheckEnvTrees) : Array Address :=
+  statement.assumptions.map (·.leaves) |>.getD #[]
+
+/-- The sorted, deduplicated candidate stream consumed by either discharge
+mode: `assumptionsL ∪ assumptionsR`. -/
+def assumptionCandidates (left right : CheckEnvTrees) : Array Address :=
+  match Ix.AssumptionTree.canonical
+      (assumptionLeaves left ++ assumptionLeaves right) with
+  | none => #[]
+  | some tree => tree.leaves
+
+/-- Canonical mode-1 fold:
+
+`subjects = subjectsL ∪ subjectsR`
+
+`assumptions = (assumptionsL ∪ assumptionsR) ∖ subjects`.
+
+The circuit independently verifies this relation with sorted linear merges;
+the host implementation uses a hash set only to construct the witness. -/
+def join (left right : CheckEnvTrees) : CheckEnvTrees :=
+  let subjectLeaves := left.subjects.leaves ++ right.subjects.leaves
+  let subjects := (Ix.AssumptionTree.canonical subjectLeaves).get!
+  let subjectSet := subjects.leaves.foldl (fun set addr => set.insert addr)
+    ({} : Std.HashSet Address)
+  let remaining := assumptionCandidates left right |>.filter
+    (fun addr => !subjectSet.contains addr)
+  { subjects, assumptions := Ix.AssumptionTree.canonical remaining }
+
+/-- Structural mode-2 fold. Subjects are committed in O(1) as a free-form
+node over the two child roots. Assumptions retain canonical set semantics and
+drop precisely those candidates for which the resulting subject forest can
+produce a membership path. -/
+def joinStructural (left right : CheckEnvTrees) : CheckEnvTrees :=
+  let subjects := Ix.AssumptionTree.join left.subjects right.subjects
+  let remaining := assumptionCandidates left right |>.filter
+    (fun addr => !subjects.contains addr)
+  { subjects, assumptions := Ix.AssumptionTree.canonical remaining }
+
+/-- One channel-6 choice per structural join candidate. `some path` discharges
+the candidate against the structural output root; `none` carries it into the
+output assumption set. `AssumptionTree.merkleProof` chooses one valid path when
+a free-form subject forest contains duplicate leaves. -/
+def structuralPathAdvice (left right output : CheckEnvTrees) :
+    Array (Address × Option Ix.Merkle.MerklePath) :=
+  assumptionCandidates left right |>.map fun candidate =>
+    (candidate, output.subjects.merkleProof candidate)
+
+/-- The present trees in channel-5 order for one binary join. Optional empty
+assumption sets contribute no advice entry. -/
+def adviceTrees (left right output : CheckEnvTrees) : Array Ix.AssumptionTree :=
+  #[left.subjects] ++ left.assumptions.toArray ++
+  #[right.subjects] ++ right.assumptions.toArray ++
+  #[output.subjects] ++ output.assumptions.toArray
+
+/-- Structural joins never open subject trees. Only the canonical input/output
+assumption trees are needed on channel 5. -/
+def structuralAdviceTrees (left right output : CheckEnvTrees) :
+    Array Ix.AssumptionTree :=
+  left.assumptions.toArray ++ right.assumptions.toArray ++
+    output.assumptions.toArray
+
+end CheckEnvTrees
+
+end MultiStark
+
+end
diff --git a/Ix/MultiStark/Pcs.lean b/Ix/MultiStark/Pcs.lean
index 82a147c20..9ac8b4c65 100644
--- a/Ix/MultiStark/Pcs.lean
+++ b/Ix/MultiStark/Pcs.lean
@@ -515,6 +515,129 @@ def pcs := ⟦
     eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(root))
   }
 
+  -- A node in the sorted multiproof frontier. Rows are retained from the
+  -- lead query so shorter matrices can be injected at their native height.
+  enum FrontierNode { Mk(G, List‹G›, List‹List‹U64››, DigestP) }
+
+  fn frontier_merge(xs: List‹FrontierNode›, ys: List‹FrontierNode›) -> List‹FrontierNode› {
+    match load(xs) {
+      ListNode.Nil => ys,
+      ListNode.Cons(x, xrest) => match load(ys) {
+        ListNode.Nil => xs,
+        ListNode.Cons(y, yrest) =>
+          let FrontierNode.Mk(xi, _xb, _xr, xd) = x;
+          let FrontierNode.Mk(yi, _yb, _yr, yd) = y;
+          match memo_u32_less_than(xi, yi) {
+            1 => store(ListNode.Cons(x, frontier_merge(xrest, ys))),
+            _ => match eq_zero(xi - yi) {
+              1 =>
+                -- Duplicate transcript queries must open the same leaf. A
+                -- direct pointer assertion is sound here: only equality is
+                -- accepted; non-canonical equal digests can at worst reject.
+                assert_eq!(ptr_val(xd), ptr_val(yd));
+                store(ListNode.Cons(x, frontier_merge(xrest, yrest))),
+              _ => store(ListNode.Cons(y, frontier_merge(xs, yrest))),
+            },
+          },
+      },
+    }
+  }
+
+  -- Deal alternating elements into two half-sized lists. Their internal order
+  -- is irrelevant because each half is recursively sorted before merging.
+  fn frontier_split(xs: List‹FrontierNode›) -> (List‹FrontierNode›, List‹FrontierNode›) {
+    match load(xs) {
+      ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)),
+      ListNode.Cons(x, rest) => match load(rest) {
+        ListNode.Nil => (store(ListNode.Cons(x, store(ListNode.Nil))), store(ListNode.Nil)),
+        ListNode.Cons(y, tail) =>
+          let (left, right) = frontier_split(tail);
+          (store(ListNode.Cons(x, left)), store(ListNode.Cons(y, right))),
+      },
+    }
+  }
+
+  fn frontier_sort(xs: List‹FrontierNode›) -> List‹FrontierNode› {
+    match load(xs) {
+      ListNode.Nil => xs,
+      ListNode.Cons(_x, rest) => match load(rest) {
+        ListNode.Nil => xs,
+        ListNode.Cons(_y, _tail) =>
+          let (left, right) = frontier_split(xs);
+          frontier_merge(frontier_sort(left), frontier_sort(right)),
+      },
+    }
+  }
+
+  fn frontier_leaves(indices: List‹List‹G››, rows: List‹List‹List‹U64›››,
+      lhs: List‹G›, log_max: G) -> List‹FrontierNode› {
+    match load(indices) {
+      ListNode.Nil =>
+        assert_eq!(list_length(rows), 0);
+        store(ListNode.Nil),
+      ListNode.Cons(bits, irest) =>
+        let &ListNode.Cons(r, rrest) = rows;
+        let d = leaf_hash_at(r, lhs, log_max);
+        store(ListNode.Cons(FrontierNode.Mk(bits_to_num(bits), bits, r, d),
+          frontier_leaves(irest, rrest, lhs, log_max))),
+    }
+  }
+
+  -- Fold one binary frontier level. Boundary siblings are consumed in the
+  -- exact ascending-parent/ascending-child order used by Plonky3 pruning.
+  fn frontier_level(nodes: List‹FrontierNode›, proof: List‹DigestP›,
+      lhs: List‹G›, next_lh: G) -> (List‹FrontierNode›, List‹DigestP›) {
+    match load(nodes) {
+      ListNode.Nil => (store(ListNode.Nil), proof),
+      ListNode.Cons(a, rest) =>
+        let FrontierNode.Mk(ai, abits, ar, ad) = a;
+        let &ListNode.Cons(abit, aparent_bits) = abits;
+        let aparent = bits_to_num(aparent_bits);
+        match load(rest) {
+          ListNode.Cons(b, brest) =>
+            let FrontierNode.Mk(bi, bbits, _br, bd) = b;
+            let &ListNode.Cons(_bbit, bparent_bits) = bbits;
+            match eq_zero(aparent - bits_to_num(bparent_bits)) {
+              1 =>
+                let parent = inject_maybe(ar, lhs, next_lh, mmcs_compress(ad, bd));
+                let (tail, p2) = frontier_level(brest, proof, lhs, next_lh);
+                (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2),
+              _ =>
+                let &ListNode.Cons(sib, prest) = proof;
+                let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib));
+                let (tail, p2) = frontier_level(rest, prest, lhs, next_lh);
+                (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), tail)), p2),
+            },
+          ListNode.Nil =>
+            let &ListNode.Cons(sib, prest) = proof;
+            let parent = inject_maybe(ar, lhs, next_lh, compress_ordered(abit, ad, sib));
+            (store(ListNode.Cons(FrontierNode.Mk(aparent, aparent_bits, ar, parent), store(ListNode.Nil))), prest),
+        },
+    }
+  }
+
+  fn frontier_fold(nodes: List‹FrontierNode›, proof: List‹DigestP›,
+      lhs: List‹G›, levels: G) -> (List‹FrontierNode›, List‹DigestP›) {
+    match levels {
+      0 => (nodes, proof),
+      _ =>
+        let (next, p2) = frontier_level(nodes, proof, lhs, levels - 1);
+        frontier_fold(next, p2, lhs, levels - 1),
+    }
+  }
+
+  fn mmcs_verify_multi(cap: MerkleCap, rows: List‹List‹List‹U64›››,
+      lhs: List‹G›, indices: List‹List‹G››, proof: List‹DigestP›, log_max: G) -> G {
+    assert_eq!(eq_zero(list_length(rows) - list_length(indices)), 1);
+    let leaves = frontier_sort(frontier_leaves(indices, rows, lhs, log_max));
+    let (roots, rest) = frontier_fold(leaves, proof, lhs, log_max);
+    assert_eq!(list_length(rest), 0);
+    let &ListNode.Cons(root, no_more) = roots;
+    assert_eq!(list_length(no_more), 0);
+    let FrontierNode.Mk(capidx, _bits, _rows, digest) = root;
+    eq_zero(ptr_val(list_lookup(cap, capidx)) - ptr_val(digest))
+  }
+
   -- ==========================================================================
   -- FRI fold step (`TwoAdicFriFolding::fold_row`, arity-2 case).
   --
@@ -826,7 +949,7 @@ def pcs := ⟦
     match prep_opt {
       PreprocessedOpt.NoPreprocessed => buckets,
       PreprocessedOpt.SomePreprocessed(prep_round) =>
-        let BatchOpening.Mk(rows_p, proof_p) = list_lookup(input_proof, 3);
+        let BatchOpening.Mk(rows_p) = list_lookup(input_proof, 3);
         -- one opened base row per preprocessed matrix (BatchOpenedValuesCountMismatch)
         assert_eq!(eq_zero(list_length(rows_p) - list_length(prep_round)), 1);
         -- The preprocessed tree's max height is over the PREP circuits only, so
@@ -836,8 +959,6 @@ def pcs := ⟦
         -- of the LSB-first bit list) and verify against the batch's own height.
         let prep_heights = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0);
         let log_pmax = heights_max(prep_heights);
-        assert_eq!(mmcs_verify(prep_commit, rows_p, prep_heights,
-          list_drop(idxbits, log_gmax - log_pmax), proof_p, log_pmax), 1);
         open_prep(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, 0, log_degrees,
                   prep_indices, zeta, rows_p, prep_round, alpha),
     }
@@ -904,7 +1025,7 @@ def pcs := ⟦
   }
   fn verify_query(folded: Ext, betas: List‹Ext›, comms: List‹MerkleCap›,
       openings: List‹CommitPhaseProofStep›, domidx: List‹G›, log_cur: G,
-      ro_rest: List‹Bucket›, log_final: G) -> Ext {
+      ro_rest: List‹Bucket›, log_final: G) -> (Ext, List‹List‹U64››) {
     match load(openings) {
       ListNode.Nil =>
         -- must have folded down to exactly the final domain size, and every
@@ -912,22 +1033,20 @@ def pcs := ⟦
         -- UnconsumedReducedOpenings).
         assert_eq!(eq_zero(log_cur - log_final), 1);
         assert_eq!(list_length(ro_rest), 0);
-        folded,
+        (folded, store(ListNode.Nil)),
       ListNode.Cons(op, op_rest) =>
         let &ListNode.Cons(beta, beta_rest) = betas;
         let &ListNode.Cons(comm, comm_rest) = comms;
-        let CommitPhaseProofStep.Mk(_la, sibs, oproof) = op;
+        let CommitPhaseProofStep.Mk(_la, sibs) = op;
         -- arity 2 ⇒ exactly arity-1 = 1 sibling (SiblingValuesLengthMismatch).
         assert_eq!(list_length(sibs), 1);
         let &ListNode.Cons(ibit, idrest) = domidx;     -- index_in_group = LSB
         let log_folded = log_cur - 1;
         let (e0, e1) = @recon_evals(ibit, folded, list_lookup(sibs, 0));
-        -- authenticate the sibling pair against this round's commitment
-        assert_eq!(mmcs_verify(comm, store(ListNode.Cons(@flatten2(e0, e1), store(ListNode.Nil))),
-          store(ListNode.Cons(log_folded, store(ListNode.Nil))), idrest, oproof, log_folded), 1);
         let folded1 = fri_fold2(idrest, log_folded, beta, e0, e1);
         let (folded2, ro_rest2) = rollin(folded1, log_folded, beta, ro_rest);
-        verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final),
+        let (result, rows) = verify_query(folded2, beta_rest, comm_rest, op_rest, idrest, log_folded, ro_rest2, log_final);
+        (result, store(ListNode.Cons(@flatten2(e0, e1), rows))),
     }
   }
 
@@ -941,7 +1060,7 @@ def pcs := ⟦
       prep_commit: MerkleCap, prep_indices: List‹OptIdx›,
       log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G,
       betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›,
-      num_rounds: G) -> G {
+      num_rounds: G) -> List‹List‹U64›› {
     let QueryProof.Mk(input_proof, commit_phase_openings) = qp;
     -- one commit-phase opening per round (QueryCommitPhaseOpeningsCountMismatch),
     -- one input batch per commitment (InputProofBatchCountMismatch).
@@ -951,19 +1070,16 @@ def pcs := ⟦
     -- one heights list for all three stage batches (memoized anyway; this
     -- also drops two call-output columns per proof)
     let hall = heights_all(log_degrees, log_blowup, num_circuits, 0);
-    let BatchOpening.Mk(rows_s1, proof_s1) = list_lookup(input_proof, 0);
+    let BatchOpening.Mk(rows_s1) = list_lookup(input_proof, 0);
     assert_eq!(eq_zero(list_length(rows_s1) - num_circuits), 1);
-    assert_eq!(mmcs_verify(s1c, rows_s1, hall, idxbits, proof_s1, log_gmax), 1);
     let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s1, stage1, alpha);
-    let BatchOpening.Mk(rows_s2, proof_s2) = list_lookup(input_proof, 1);
+    let BatchOpening.Mk(rows_s2) = list_lookup(input_proof, 1);
     assert_eq!(eq_zero(list_length(rows_s2) - num_circuits), 1);
-    assert_eq!(mmcs_verify(s2c, rows_s2, hall, idxbits, proof_s2, log_gmax), 1);
     let buckets = open_batch_2pt(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_s2, stage2, alpha);
-    let BatchOpening.Mk(rows_q, proof_q) = list_lookup(input_proof, 2);
+    let BatchOpening.Mk(rows_q) = list_lookup(input_proof, 2);
     -- one wide quotient matrix per circuit, on the trace domain, so the
     -- quotient batch's heights are the same per-circuit heights as the stages
     assert_eq!(eq_zero(list_length(rows_q) - num_circuits), 1);
-    assert_eq!(mmcs_verify(qc, rows_q, hall, idxbits, proof_q, log_gmax), 1);
     let buckets = open_quotient(buckets, idxbits, log_gmax, log_blowup, 0, num_circuits, log_degrees, zeta, rows_q, q_opened, alpha);
     let buckets = open_prep_batch(buckets, input_proof, prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, idxbits, log_gmax, log_blowup, zeta, alpha);
     -- a height-`log_blowup` (constant-poly) reduced opening must be zero
@@ -973,10 +1089,10 @@ def pcs := ⟦
     let &ListNode.Cons(b0, ro_rest) = buckets;
     let Bucket.Mk(h0, _ap0, folded_start) = b0;
     assert_eq!(eq_zero(h0 - log_gmax), 1);
-    let folded = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
+    let (folded, fri_rows) = verify_query(folded_start, betas, commit_phase_commits, commit_phase_openings, idxbits, log_gmax, ro_rest, log_blowup);
     -- final check: with log_final_poly_len = 0, eval = final_poly[0]
     assert_eq!(@eg_eq(list_lookup(final_poly, 0), folded), 1);
-    1
+    fri_rows
   }
 
   -- Loop over all `num_queries` query proofs, sampling one index per query
@@ -987,17 +1103,106 @@ def pcs := ⟦
       prep_commit: MerkleCap, prep_indices: List‹OptIdx›,
       log_degrees: List‹U8›, zeta: Ext, num_circuits: G, log_blowup: G, log_gmax: G,
       betas: List‹Ext›, commit_phase_commits: List‹MerkleCap›, final_poly: List‹Ext›,
-      num_rounds: G) -> G {
+      num_rounds: G) -> List‹List‹List‹U64››› {
     match load(query_proofs) {
-      ListNode.Nil => 1,
+      ListNode.Nil => store(ListNode.Nil),
       ListNode.Cons(qp, rest) =>
         let (idxbits, input2, output2) = ch_sample_bits(input, output, log_gmax);
-        let _q = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt,
+        let qrows = verify_one_query(idxbits, qp, alpha, stage1, stage2, q_opened, prep_opt,
           s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits,
           log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds);
-        query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt,
+        store(ListNode.Cons(qrows, query_loop(input2, output2, rest, alpha, stage1, stage2, q_opened, prep_opt,
           s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta, num_circuits,
-          log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds),
+          log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds))),
+    }
+  }
+
+  fn sample_query_indices(input: ByteStream, output: ByteStream, n: G,
+      log_gmax: G) -> List‹List‹G›› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ =>
+        let (bits, input2, output2) = ch_sample_bits(input, output, log_gmax);
+        store(ListNode.Cons(bits, sample_query_indices(input2, output2, n - 1, log_gmax))),
+    }
+  }
+
+  fn batch_views_at(bs: List‹BatchMultiOpening›, q: G) -> List‹BatchOpening› {
+    match load(bs) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(b, rest) =>
+        let BatchMultiOpening.Mk(rows, _proof) = b;
+        store(ListNode.Cons(BatchOpening.Mk(list_lookup(rows, q)), batch_views_at(rest, q))),
+    }
+  }
+  fn step_views_at(ss: List‹CommitPhaseMultiStep›, q: G) -> List‹CommitPhaseProofStep› {
+    match load(ss) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(s, rest) =>
+        let CommitPhaseMultiStep.Mk(la, sibs, _proof) = s;
+        store(ListNode.Cons(CommitPhaseProofStep.Mk(la, list_lookup(sibs, q)), step_views_at(rest, q))),
+    }
+  }
+  fn query_views(bs: List‹BatchMultiOpening›, ss: List‹CommitPhaseMultiStep›,
+      q: G, n: G) -> List‹QueryProof› {
+    match n {
+      0 => store(ListNode.Nil),
+      _ => store(ListNode.Cons(QueryProof.Mk(batch_views_at(bs, q), step_views_at(ss, q)),
+             query_views(bs, ss, q + 1, n - 1))),
+    }
+  }
+
+  fn verify_input_multi(bs: List‹BatchMultiOpening›, indices: List‹List‹G››,
+      s1c: MerkleCap, s2c: MerkleCap, qc: MerkleCap, prep_commit: MerkleCap,
+      prep_opt: PreprocessedOpt, prep_indices: List‹OptIdx›, log_degrees: List‹U8›,
+      num_circuits: G, log_blowup: G, log_gmax: G) -> G {
+    let hall = heights_all(log_degrees, log_blowup, num_circuits, 0);
+    let BatchMultiOpening.Mk(s1rows, s1proof) = list_lookup(bs, 0);
+    let BatchMultiOpening.Mk(s2rows, s2proof) = list_lookup(bs, 1);
+    let BatchMultiOpening.Mk(qrows, qproof) = list_lookup(bs, 2);
+    assert_eq!(mmcs_verify_multi(s1c, s1rows, hall, indices, s1proof, log_gmax), 1);
+    assert_eq!(mmcs_verify_multi(s2c, s2rows, hall, indices, s2proof, log_gmax), 1);
+    assert_eq!(mmcs_verify_multi(qc, qrows, hall, indices, qproof, log_gmax), 1);
+    match prep_opt {
+      PreprocessedOpt.NoPreprocessed => 1,
+      PreprocessedOpt.SomePreprocessed(_round) =>
+        let BatchMultiOpening.Mk(prows, pproof) = list_lookup(bs, 3);
+        let ph = heights_prep(log_degrees, log_blowup, prep_indices, num_circuits, 0);
+        let lp = heights_max(ph);
+        let pindices = drop_index_bits(indices, log_gmax - lp);
+        mmcs_verify_multi(prep_commit, prows, ph, pindices, pproof, lp),
+    }
+  }
+  fn drop_index_bits(indices: List‹List‹G››, n: G) -> List‹List‹G›› {
+    match load(indices) {
+      ListNode.Nil => indices,
+      ListNode.Cons(bits, rest) =>
+        store(ListNode.Cons(list_drop(bits, n), drop_index_bits(rest, n))),
+    }
+  }
+  fn rows_at_round(rows: List‹List‹List‹U64›››, r: G) -> List‹List‹List‹U64››› {
+    match load(rows) {
+      ListNode.Nil => store(ListNode.Nil),
+      ListNode.Cons(qrows, rest) =>
+        store(ListNode.Cons(store(ListNode.Cons(list_lookup(qrows, r), store(ListNode.Nil))),
+          rows_at_round(rest, r))),
+    }
+  }
+  fn verify_commit_multi(steps: List‹CommitPhaseMultiStep›, comms: List‹MerkleCap›,
+      all_rows: List‹List‹List‹U64›››, indices: List‹List‹G››, r: G,
+      log_cur: G) -> G {
+    match load(steps) {
+      ListNode.Nil => eq_zero(list_length(comms)),
+      ListNode.Cons(s, srest) =>
+        let &ListNode.Cons(c, crest) = comms;
+        let CommitPhaseMultiStep.Mk(la, sibs, proof) = s;
+        assert_eq!(to_field(la), 1);
+        assert_eq!(list_length(sibs), list_length(indices));
+        let next_indices = drop_index_bits(indices, 1);
+        let lh = log_cur - 1;
+        assert_eq!(mmcs_verify_multi(c, rows_at_round(all_rows, r),
+          store(ListNode.Cons(lh, store(ListNode.Nil))), next_indices, proof, lh), 1);
+        verify_commit_multi(srest, crest, all_rows, next_indices, r + 1, lh),
     }
   }
 
@@ -1010,12 +1215,14 @@ def pcs := ⟦
       prep_indices: List‹OptIdx›, log_degrees: List‹U8›,
       zeta: Ext, num_circuits: G, log_blowup: G, num_queries: G, commit_pow_bits: G,
       query_pow_bits: G) -> G {
-    let FriProof.Mk(commit_phase_commits, pw, query_proofs, final_poly, qpw) = opening;
+    let FriProof.Mk(commit_phase_commits, pw, input_openings, commit_phase_openings,
+      final_poly, qpw) = opening;
     let num_rounds = list_length(commit_phase_commits);
     -- FRI shape: one PoW witness per round, num_queries query proofs, and (since
     -- log_final_poly_len = 0) a single final-poly coefficient.
     assert_eq!(eq_zero(list_length(pw) - num_rounds), 1);
-    assert_eq!(eq_zero(list_length(query_proofs) - num_queries), 1);
+    assert_eq!(list_length(input_openings), 3 + prep_count(prep_opt));
+    assert_eq!(eq_zero(list_length(commit_phase_openings) - num_rounds), 1);
     assert_eq!(list_length(final_poly), 1);
     -- challenger continuation: observe all opened values (coms_to_verify
     -- order), built as one front-to-back suffix + a single concat (the input
@@ -1041,9 +1248,14 @@ def pcs := ⟦
     -- max height so `two_adic_gen`'s squaring chain (bits ≤ 32) and the
     -- 32-bit query-index decomposition stay within range.
     assert_eq!(u32_less_than(log_gmax, 33), 1);
-    query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened,
+    let indices = sample_query_indices(input, output, num_queries, log_gmax);
+    assert_eq!(verify_input_multi(input_openings, indices, s1c, s2c, qc,
+      prep_commit, prep_opt, prep_indices, log_degrees, num_circuits, log_blowup, log_gmax), 1);
+    let query_proofs = query_views(input_openings, commit_phase_openings, 0, num_queries);
+    let fri_rows = query_loop(input, output, query_proofs, alpha, stage1, stage2, q_opened,
       prep_opt, s1c, s2c, qc, prep_commit, prep_indices, log_degrees, zeta,
-      num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds)
+      num_circuits, log_blowup, log_gmax, betas, commit_phase_commits, final_poly, num_rounds);
+    verify_commit_multi(commit_phase_openings, commit_phase_commits, fri_rows, indices, 0, log_gmax)
   }
 
 ⟧
diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean
index 05ff6c915..7e30323ad 100644
--- a/Ix/MultiStark/SystemDeserialize.lean
+++ b/Ix/MultiStark/SystemDeserialize.lean
@@ -43,10 +43,11 @@ deserializer calls are constrained, so the public `system_digest` binds every
 value reconstructed below. Per-node degrees are neither serialized nor needed
 (the node sweep just evaluates the graph).
 
-The Fiat-Shamir shape limbs (`observe_shape`): the circuit count then,
-per circuit, the seven words constraint_count, max_constraint_degree,
-preprocessed_height, preprocessed_width, main_width, stage_2_width,
-lookup_group_size (as 8-byte LE limbs).
+The Fiat-Shamir shape limbs (`observe_shape`): the width-binding policy
+word, the circuit count, then per circuit the seven words
+constraint_count, max_constraint_degree, preprocessed_height,
+preprocessed_width, main_width, stage_2_width, lookup_group_size (as
+8-byte LE limbs).
 -/
 
 public section
@@ -97,7 +98,8 @@ def systemDeserialize := ⟦
   -- preprocessed_indices. The transcript limbs are the u64 words the
   -- challenger observes before any commitment — the 7 parameters (bound via
   -- the challenger seed) followed by the system shape (`observe_shape`: the
-  -- circuit count, then 6 metadata words per circuit) — kept as limbs because
+  -- width-binding policy word, the circuit count, then 7 metadata words per
+  -- circuit) — kept as limbs because
   -- the Fiat-Shamir replay needs their little-endian bytes.
   enum Sys { Mk(SysParams, List‹U64›, List‹SysCircuit›, OptCommit, List‹OptIdx›) }
 
@@ -316,7 +318,12 @@ def systemDeserialize := ⟦
 
   fn read_sys_lookup(i: ByteStream) -> (SysLookup, ByteStream) {
     let (m, i1) = read_vk_u16(i);
-    let (ac, i2) = read_vk_u16(i1);
+    -- The declared per-row multiplicity bound (u64 LE). It feeds the logUp
+    -- height bound, which the native verifier enforces; the in-circuit
+    -- verifier does not enforce it yet, so the value is parsed past and
+    -- bound only through the vk digest.
+    let (_mm, i1b) = read_vk_u64(i1);
+    let (ac, i2) = read_vk_u16(i1b);
     let (args, i3) = read_node_ids_n(i2, ac);
     (SysLookup.Mk(m, args), i3)
   }
@@ -450,8 +457,13 @@ def systemDeserialize := ⟦
     let (circuits, climbs, j2) = read_sys_circuits_n(j1, n);
     let (commit, j3) = read_opt_commit(j2);
     let (indices, j4) = read_opt_idx_n(j3, n);
+    -- The width-binding policy is the first `observe_shape` word. Aiur
+    -- declares `WidthBinding::ByConstruction` (discriminant 1); the plain
+    -- Horner fold in `logup_fingerprint` is the matching message shape.
+    let wblimb = @gl_to_bytes(1);
     (Sys.Mk(params,
-            list_concat(plimbs, store(ListNode.Cons(nlimb, climbs))),
+            list_concat(plimbs,
+              store(ListNode.Cons(wblimb, store(ListNode.Cons(nlimb, climbs))))),
             circuits, commit, indices),
      j4)
   }
diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean
index b11b6a79e..b6487075b 100644
--- a/Ix/MultiStark/Verifier.lean
+++ b/Ix/MultiStark/Verifier.lean
@@ -308,8 +308,9 @@ def verifier := ⟦
   -- Replay the verifier transcript and derive the four challenges
   -- `(lookup, fingerprint, alpha, zeta)`. Mirrors `verify_multiple_claims`'s
   -- challenger sequence exactly:
-  --   seed = tag + protocol parameters; observe_shape (circuit count + 6
-  --   metadata words per circuit) → preprocessed_commit (if any) → stage_1 →
+  --   seed = tag + protocol parameters; observe_shape (width-binding policy
+  --   word, circuit count, 7 metadata words per circuit) → preprocessed_commit
+  --   (if any) → stage_1 →
   --   log_degrees → length-prefixed claims;
   --   sample lookup, observe it; sample fingerprint, observe it;
   --   observe stage_2; observe the intermediate accumulators; sample α;
@@ -602,7 +603,9 @@ def verifier := ⟦
      @eg_add(@eg_mul(a0, b1), @eg_mul(a1, b0)))
   }
 
-  -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair:
+  -- fingerprint(γ, args) = Σᵢ argsᵢ·γ^i as a coordinate pair — the plain
+  -- Horner fold of `WidthBinding::ByConstruction`, the policy aiur declares
+  -- (and the transcript replay observes):
   -- fp(Cons(a, rest)) = (eval a, 0) + γ ⊗ fp(rest); args embed in coord 0.
   fn logup_fingerprint(args: List‹G›, g0: Ext, g1: Ext, nodes: List‹SysNode›,
       main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›,
@@ -871,9 +874,17 @@ def verifier := ⟦
     -- `query_pow_bits`) all come from the verifying key, which the public
     -- statement binds through `system_digest` — no separate public inputs.
     let Sys.Mk(params, tlimbs, circuits, commit, prep_indices) = sys;
-    let SysParams.Mk(log_blowup, _cap_height, _log_final_poly_len,
-                     _max_log_arity, num_queries, commit_pow_bits,
+    let SysParams.Mk(log_blowup, cap_height, log_final_poly_len,
+                     max_log_arity, num_queries, commit_pow_bits,
                      query_pow_bits) = params;
+    -- This recursive verifier is deliberately specialized to root caps,
+    -- binary FRI folds, and a constant final polynomial. These parameters are
+    -- digest-bound but still prover-visible inputs to this circuit, so reject
+    -- unsupported systems explicitly instead of silently applying the wrong
+    -- Merkle geometry or folding semantics.
+    assert_eq!(cap_height, 0);
+    assert_eq!(log_final_poly_len, 0);
+    assert_eq!(max_log_arity, 1);
     let Proof.Mk(active, commitments, accs, log_degrees, opening,
                  q_opened, prep_opt, stage1, stage2) = proof;
     -- Sparse activation: the bitmap covers the canonical circuit set;
diff --git a/Ix/Store.lean b/Ix/Store.lean
index 08c323be4..50a6155a8 100644
--- a/Ix/Store.lean
+++ b/Ix/Store.lean
@@ -38,6 +38,16 @@ def storeDir : StoreIO FilePath := do
     IO.toEIO .ioError (IO.FS.createDirAll path)
   return path
 
+/-- `~/.ix/cache/<namespace>` holds wipeable, keyed indexes into the
+content-addressed store. Unlike `storeDir`, filenames here are caller-defined
+lookup keys and their contents must always be treated as untrusted hints. -/
+def cacheDir (namespace' : String) : StoreIO FilePath := do
+  let home ← getHomeDir
+  let path := home / ".ix" / "cache" / namespace'
+  if !(<- path.pathExists) then
+    IO.toEIO .ioError (IO.FS.createDirAll path)
+  return path
+
 def storePath (addr: Address): StoreIO FilePath := do
   let store <- storeDir
   let hex := hexOfBytes addr.hash
diff --git a/Main.lean b/Main.lean
index fd0fe0980..6963f1ad3 100644
--- a/Main.lean
+++ b/Main.lean
@@ -1,5 +1,6 @@
 --import Ix.Cli.StoreCmd
 import Ix.Cli.AddrOfCmd
+import Ix.Cli.AggregateCmd
 import Ix.Cli.BenchReport
 import Ix.Cli.CheckCmd
 import Ix.Cli.CodegenCmd
@@ -35,6 +36,7 @@ def ixCmd : Cli.Cmd := `[Cli|
   SUBCOMMANDS:
     --storeCmd;
     benchCmd;
+    aggregateCmd;
     catalogCmd;
     compileCmd;
     decompileCmd;
diff --git a/Tests/Aggr.lean b/Tests/Aggr.lean
new file mode 100644
index 000000000..77948cc6c
--- /dev/null
+++ b/Tests/Aggr.lean
@@ -0,0 +1,582 @@
+module
+
+public import LSpec
+public import Ix.Aggr
+public import Ix.Claim
+public import Ix.AssumptionTree
+public import Ix.Cli.AggregateCmd
+public import Tests.MultiStark
+
+/-!
+# Tests for the heterogeneous `ix_aggr` circuit
+
+`ix-aggr` — `smokeSuite`. Executes the production `ix_aggr` entrypoint (the
+pure-Lean interpreter over a Lean-built IO buffer) across all ten shapes, with
+real Multi-STARK child proofs from two cheap stand-in systems:
+
+* a "fake IxVM" system whose `fake_verify_claim` reproduces `verify_claim`'s
+  10-word claim layout, and
+* a "fake self" system (same bytecode, different FRI parameters, hence a
+  different verifying key) whose `fake_aggr` reproduces `ix_aggr`'s 18-word
+  claim layout.
+
+The circuit under test still verifies real proofs and enforces every binding:
+per-kind vk digests, entrypoint indices, the transitive allowed digest of self
+children, wrap digest pass-through, canonical union/difference folding, and
+structural root/path folding. The negative cases each break exactly one of
+those bindings.
+
+Proving the real `ix_aggr` system recursively (self children that are actual
+`ix_aggr` proofs) needs the native prover and tens of GiB; that path belongs to
+the CLI/benchmark layer, not this suite.
+-/
+
+public section
+
+open LSpec Aiur
+
+namespace Tests.Aggr
+
+open Tests.MultiStark (expectOk expectErr recCommitParams innerFri)
+
+/-- Cheap stand-in children. `fake_verify_claim` mirrors the IxVM
+`verify_claim` claim shape (10 words), `fake_aggr` mirrors the `ix_aggr` claim
+shape (18 words). Bodies touch memory so the proofs have a non-trivial trace. -/
+def childProgram : Source.Toplevel := ⟦
+  pub fn fake_verify_claim(digest: [G; 8]) {
+    assert_eq!(load(store(digest[0])), digest[0]);
+    ()
+  }
+  pub fn fake_aggr(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) {
+    assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]);
+    ()
+  }
+⟧
+
+private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree :=
+  (Ix.AssumptionTree.canonical leaves).get!
+
+/-- One child slot: expanded proof advice on channel 0, serialized claims on
+channel 2. Compact proof wire bytes are never an in-circuit input. -/
+private structure ChildSlot where
+  proofAdviceBytes : ByteArray
+  claimsBytes : ByteArray
+
+/-- Assemble the full advice buffer the way the native FFI will: identity blob
+and shape byte, per-kind vks, child slots in key order, then the optional
+output claim, `CheckEnv` preimages, and canonical trees. -/
+private def mkIO (allowed : ByteArray) (shape : Nat)
+    (ixvmVk aggrVk : ByteArray) (children : Array ChildSlot)
+    (outClaim? : Option ByteArray := none)
+    (preimages : Array ByteArray := #[])
+    (trees : Array Ix.AssumptionTree := #[])
+    (paths : Array (Address × Option Ix.Merkle.MerklePath) := #[]) :
+    IOBuffer := Id.run do
+  let mut io := Aggr.extendIdentity default allowed shape
+  io := Aggr.extendVk io .ixvm ixvmVk
+  io := Aggr.extendVk io .aggr aggrVk
+  for (child, key) in children.mapIdx (fun key child => (child, key)) do
+    io := Aggr.extendChild io key child.proofAdviceBytes child.claimsBytes
+  if let some bytes := outClaim? then
+    io := Aggr.extendOutputClaim io bytes
+  for bytes in preimages do
+    io := Aggr.extendPreimage io bytes
+  for tree in trees do
+    io := Aggr.extendTree io tree
+  for (candidate, path?) in paths do
+    io := Aggr.extendPath io candidate path?
+  return io
+
+def smokeSuite : IO UInt32 := do
+  let childCompiled ← match childProgram.compile with
+    | .error e => IO.eprintln s!"aggr child compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let fakeVerifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get!
+  let fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr |>.get!
+  -- Two DIFFERENT verifying keys from one bytecode: the "self" system tunes
+  -- the query count, so a child proof only verifies under its own kind's vk
+  -- and the per-kind digest binding is meaningfully exercised.
+  let ixvmSystem := AiurSystem.build childCompiled.bytecode recCommitParams innerFri
+  let aggrSystem := AiurSystem.build childCompiled.bytecode recCommitParams
+    { innerFri with numQueries := 4 }
+  let ixvmVk := ixvmSystem.vkBytes
+  let aggrVk := aggrSystem.vkBytes
+  let allowed := Aggr.allowedBlob ixvmVk fakeVerifyIdx aggrVk fakeAggrIdx
+
+  -- ── the production system under test ────────────────────────────────────
+  let aggrTop ← match Aggr.ixAggr with
+    | .error e => IO.eprintln s!"ixAggr toplevel merge failed: {e}"; return 1
+    | .ok t => pure t
+  let aggrCompiled ← match aggrTop.compile with
+    | .error e => IO.eprintln s!"ixAggr compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let some ixAggrIdx := aggrCompiled.getFuncIdx `ix_aggr
+    | IO.eprintln "ix_aggr entrypoint not found"; return 1
+  -- The Ix-agnostic lift entrypoint must NOT survive the ixAggr prune.
+  let liftPruned := aggrCompiled.getFuncIdx `verify_multi_stark_proof |>.isNone
+
+  -- ── two shard statements whose assumptions cross the subject boundary ───
+  --   subjects    = {a,b} ∪ {c}             = {a,b,c}
+  --   assumptions = ({c,d} ∪ {a}) ∖ {a,b,c} = {d}
+  let a := Address.blake3 "aggr-a".toUTF8
+  let b := Address.blake3 "aggr-b".toUTF8
+  let c := Address.blake3 "aggr-c".toUTF8
+  let d := Address.blake3 "aggr-d".toUTF8
+  let e := Address.blake3 "aggr-extra".toUTF8
+  let leftStatement : Aggr.CheckEnvTrees :=
+    { subjects := canonicalTree #[a, b]
+      assumptions := some (canonicalTree #[c, d]) }
+  let rightStatement : Aggr.CheckEnvTrees :=
+    { subjects := canonicalTree #[c]
+      assumptions := some (canonicalTree #[a]) }
+  let outputStatement := leftStatement.join rightStatement
+  let adviceTrees := Aggr.CheckEnvTrees.adviceTrees
+    leftStatement rightStatement outputStatement
+  let leftClaimBytes := Ix.Claim.ser leftStatement.claim
+  let rightClaimBytes := Ix.Claim.ser rightStatement.claim
+  let outputClaimBytes := Ix.Claim.ser outputStatement.claim
+  let structuralOutput := leftStatement.joinStructural rightStatement
+  let structuralClaimBytes := Ix.Claim.ser structuralOutput.claim
+  let structuralTrees := Aggr.CheckEnvTrees.structuralAdviceTrees
+    leftStatement rightStatement structuralOutput
+  let structuralPathAdvice := Aggr.CheckEnvTrees.structuralPathAdvice
+    leftStatement rightStatement structuralOutput
+
+  -- ── M1-d production policy / claim derivation ──────────────────────────
+  -- Three leaves make the direct policy exercise both the IxVM+IxVM and
+  -- aggregate+IxVM pair shapes. The threshold keeps the lower fold flat and
+  -- the root structural.
+  let driverOps : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp :=
+    #[.leaf 0, .leaf 1, .join 0 1, .leaf 2, .join 2 3]
+  let defaultDriverPlan := Ix.Cli.AggregateCmd.schedulePlan
+    driverOps #[2, 1, 1] 3
+  let directDriverPlan := Ix.Cli.AggregateCmd.schedulePlan
+    driverOps #[2, 1, 1] 3 true
+  let singletonDirectPlan := Ix.Cli.AggregateCmd.schedulePlan
+    #[.leaf 0] #[2] 0 true
+  -- M1-f's four-shard box fixture is a balanced post-order fold. With every
+  -- pair above the structural threshold, wrap-first proves 0×4 then 9×3;
+  -- direct mode keeps leaves raw, proves two shape-6 lower pairs, then shape 9.
+  let m1fOps : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp := #[
+    .leaf 0, .leaf 1, .join 0 1,
+    .leaf 2, .leaf 3, .join 3 4,
+    .join 2 5
+  ]
+  let m1fWrapPlan := Ix.Cli.AggregateCmd.schedulePlan
+    m1fOps #[2500, 2500, 2500, 2500] 4096
+  let m1fDirectPlan := Ix.Cli.AggregateCmd.schedulePlan
+    m1fOps #[2500, 2500, 2500, 2500] 4096 true
+  let wrapFirstShapes : Bool := match defaultDriverPlan with
+    | .ok plan =>
+      plan.map (·.shape?) == #[some 0, some 0, some 5, some 0, some 9] &&
+        plan.all (·.kind == .aggr)
+    | .error _ => false
+  let directShapes : Bool := match directDriverPlan with
+    | .ok plan =>
+      plan.map (·.shape?) == #[none, none, some 2, none, some 8] &&
+        plan.map (·.kind) == #[.ixvm, .ixvm, .aggr, .ixvm, .aggr]
+    | .error _ => false
+  let singletonStillWraps : Bool := match singletonDirectPlan with
+    | .ok #[slot] => slot.kind == .aggr && slot.shape? == some 0
+    | _ => false
+  let m1fWrapShapes : Bool := match m1fWrapPlan with
+    | .ok plan =>
+      plan.map (·.shape?) ==
+        #[some 0, some 0, some 9, some 0, some 0, some 9, some 9] &&
+      plan.all (·.kind == .aggr)
+    | .error _ => false
+  let m1fDirectShapes : Bool := match m1fDirectPlan with
+    | .ok plan =>
+      plan.map (·.shape?) ==
+        #[none, none, some 6, none, none, some 6, some 9] &&
+      plan.map (·.kind) ==
+        #[.ixvm, .ixvm, .aggr, .ixvm, .ixvm, .aggr, .aggr]
+    | .error _ => false
+  let shapeWeightsBounded : Bool := match defaultDriverPlan, directDriverPlan with
+    | .ok wraps, .ok direct =>
+      Ix.Cli.AggregateCmd.aggregateSlotRamWeights wraps == #[
+        Ix.Cli.AggregateCmd.aggregateWrapRamBytes,
+        Ix.Cli.AggregateCmd.aggregateWrapRamBytes,
+        Ix.Cli.AggregateCmd.aggregateStructuralJoinRamBytes +
+          3 * Ix.Cli.AggregateCmd.aggregateFlatJoinRamPerSubjectBytes,
+        Ix.Cli.AggregateCmd.aggregateWrapRamBytes,
+        Ix.Cli.AggregateCmd.aggregateStructuralJoinRamBytes] &&
+      Ix.Cli.AggregateCmd.aggregateSlotRamWeights direct == #[
+        Ix.Cli.AggregateCmd.aggregateRawShardRamBytes,
+        Ix.Cli.AggregateCmd.aggregateRawShardRamBytes,
+        Ix.Cli.AggregateCmd.aggregateDirectJoinRamBytes,
+        Ix.Cli.AggregateCmd.aggregateRawShardRamBytes,
+        Ix.Cli.AggregateCmd.aggregateMixedJoinRamBytes]
+    | _, _ => false
+  let driverPrepared : Array Ix.Cli.AggregateCmd.PreparedShard := #[
+    { claim := leftStatement.claim
+      statement := Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees leftStatement },
+    { claim := rightStatement.claim
+      statement := Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees rightStatement },
+    { claim := rightStatement.claim
+      statement := Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees rightStatement }
+  ]
+  let driverParameters : MultiStark.RecursionParameters := {
+    commitment := recCommitParams, fri := innerFri
+  }
+  let defaultDriverSpecs := defaultDriverPlan.bind fun plan =>
+    Ix.Cli.AggregateCmd.buildAggrSlotSpecs plan driverPrepared aggrVk allowed
+      fakeVerifyIdx fakeAggrIdx driverParameters
+  let directDriverSpecs := directDriverPlan.bind fun plan =>
+    Ix.Cli.AggregateCmd.buildAggrSlotSpecs plan driverPrepared aggrVk allowed
+      fakeVerifyIdx fakeAggrIdx driverParameters
+  let uniformDriverClaims : Bool := match defaultDriverSpecs, directDriverSpecs with
+    | .ok wraps, .ok direct => match wraps[0]?, wraps.back?, direct[0]?, direct.back? with
+      | some wrappedLeaf, some wrappedRoot, some rawLeaf, some directRoot =>
+        wrappedLeaf.outerClaim == Ix.Cli.AggregateCmd.aggregateOuterClaim
+          allowed fakeAggrIdx leftStatement.claim &&
+        rawLeaf.kind == .ixvm && directRoot.kind == .aggr &&
+        wrappedRoot.outerClaim == directRoot.outerClaim &&
+        Ix.Cli.AggregateCmd.aggregateCacheVersion == 2 &&
+        wrappedLeaf.cacheKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+          aggrVk driverParameters wrappedLeaf.outerClaim 1
+      | _, _, _, _ => false
+    | _, _ => false
+
+  -- ── child proofs ────────────────────────────────────────────────────────
+  -- Kind 0 ("IxVM"): claim = [0, fake_verify_claim, digest(CheckEnv bytes)].
+  let mkIxvmChild (claimBytes : ByteArray) : Except String ChildSlot := do
+    let (claim, proof, _) ←
+      ixvmSystem.prove fakeVerifyIdx (Aggr.digestGs claimBytes) default
+    let proofAdviceBytes ← ixvmSystem.proofToAdviceBytes claim proof
+    pure ⟨proofAdviceBytes, MultiStark.serializeClaims #[claim]⟩
+  -- Kind 1 ("self"): claim = [0, fake_aggr, digest(allowed), digest(CheckEnv)].
+  let mkSelfChild (blob claimBytes : ByteArray) : Except String ChildSlot := do
+    let (claim, proof, _) ←
+      aggrSystem.prove fakeAggrIdx (Aggr.pubInput blob claimBytes) default
+    let proofAdviceBytes ← aggrSystem.proofToAdviceBytes claim proof
+    pure ⟨proofAdviceBytes, MultiStark.serializeClaims #[claim]⟩
+  let leftIxvm ← match mkIxvmChild leftClaimBytes with
+    | .error e => IO.eprintln s!"left IxVM proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+  let rightIxvm ← match mkIxvmChild rightClaimBytes with
+    | .error e => IO.eprintln s!"right IxVM proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+  let leftSelf ← match mkSelfChild allowed leftClaimBytes with
+    | .error e => IO.eprintln s!"left self proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+  let rightSelf ← match mkSelfChild allowed rightClaimBytes with
+    | .error e => IO.eprintln s!"right self proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+  let structuralSelf ← match mkSelfChild allowed structuralClaimBytes with
+    | .error e => IO.eprintln s!"structural self proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+
+  let run (shape : Nat) (children : Array ChildSlot) (outBytes : ByteArray)
+      (outClaim? : Option ByteArray := none)
+      (preimages : Array ByteArray := #[])
+      (trees : Array Ix.AssumptionTree := #[])
+      (paths : Array (Address × Option Ix.Merkle.MerklePath) := #[]) :=
+    aggrCompiled.bytecode.execute ixAggrIdx (Aggr.pubInput allowed outBytes)
+      (mkIO allowed shape ixvmVk aggrVk children outClaim? preimages trees paths)
+  let pairShape (l r : Aggr.ChildKind) := Aggr.shapeCode (l, some r)
+  let runPair (l r : Aggr.ChildKind) (leftChild rightChild : ChildSlot) :=
+    run (pairShape l r) #[leftChild, rightChild] outputClaimBytes
+      (outClaim? := some outputClaimBytes)
+      (preimages := #[leftClaimBytes, rightClaimBytes])
+      (trees := adviceTrees)
+  let runStructural (l r : Aggr.ChildKind)
+      (leftChild rightChild : ChildSlot)
+      (paths := structuralPathAdvice) :=
+    run (Aggr.structuralShapeCode l r) #[leftChild, rightChild]
+      structuralClaimBytes (outClaim? := some structuralClaimBytes)
+      (preimages := #[leftClaimBytes, rightClaimBytes])
+      (trees := structuralTrees) (paths := paths)
+
+  IO.println "ix-aggr (proving stand-in children + interpreting all shapes)…"
+  (← IO.getStdout).flush
+
+  -- ── positive shapes ─────────────────────────────────────────────────────
+  let wrapIxvm := run (Aggr.shapeCode (.ixvm, none)) #[leftIxvm] leftClaimBytes
+  let wrapSelf := run (Aggr.shapeCode (.aggr, none)) #[leftSelf] leftClaimBytes
+  let pairII := runPair .ixvm .ixvm leftIxvm rightIxvm
+  let pairIA := runPair .ixvm .aggr leftIxvm rightSelf
+  let pairAI := runPair .aggr .ixvm leftSelf rightIxvm
+  let pairAA := runPair .aggr .aggr leftSelf rightSelf
+  let structuralII := runStructural .ixvm .ixvm leftIxvm rightIxvm
+  let structuralIA := runStructural .ixvm .aggr leftIxvm rightSelf
+  let structuralAI := runStructural .aggr .ixvm leftSelf rightIxvm
+  let structuralAA := runStructural .aggr .aggr leftSelf rightSelf
+
+  -- A structural parent consumes a structural child's free-form subject root
+  -- opaquely. This is the monotone composition path used above the scheduler
+  -- threshold: once structural, all ancestors remain structural.
+  let nestedStructuralOutput := structuralOutput.joinStructural rightStatement
+  let nestedStructuralBytes := Ix.Claim.ser nestedStructuralOutput.claim
+  let nestedStructural := run (Aggr.structuralShapeCode .aggr .ixvm)
+    #[structuralSelf, rightIxvm] nestedStructuralBytes
+    (outClaim? := some nestedStructuralBytes)
+    (preimages := #[structuralClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.structuralAdviceTrees
+      structuralOutput rightStatement nestedStructuralOutput)
+    (paths := Aggr.CheckEnvTrees.structuralPathAdvice
+      structuralOutput rightStatement nestedStructuralOutput)
+
+  -- ── codegen/native parity ───────────────────────────────────────────────
+  -- The generated Rust aggregator (`crates/ixvm-codegen/src/aiur_ix_aggr.rs`)
+  -- plus the native advice builder must reproduce the interpreter's output
+  -- and per-circuit query counts exactly — the standing parity invariant.
+  let sameCounts (native : Except String (Array Aiur.G × Array QueryCount))
+      (interp : Except String (Array Aiur.G × IOBuffer × Array QueryCount)) :
+      Bool :=
+    match native, interp with
+    | .ok (out, qc), .ok (outI, _, qcI) =>
+      out == outI && qc.size == qcI.size &&
+        (qc.zip qcI).all fun (a, b) =>
+          a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits
+    | _, _ => false
+  let nativePair := aggrCompiled.bytecode.executeIxAggr ixAggrIdx
+    (Aggr.pubInput allowed outputClaimBytes) (pairShape .ixvm .ixvm)
+    leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk
+    leftIxvm.claimsBytes rightIxvm.claimsBytes outputClaimBytes allowed
+    (Aggr.preimagesBlob #[leftClaimBytes, rightClaimBytes])
+    (Aggr.treesBlob adviceTrees) (Aggr.pathsBlob #[])
+  let nativeWrap := aggrCompiled.bytecode.executeIxAggr ixAggrIdx
+    (Aggr.pubInput allowed leftClaimBytes) (Aggr.shapeCode (.ixvm, none))
+    leftIxvm.proofAdviceBytes ByteArray.empty ixvmVk aggrVk
+    leftIxvm.claimsBytes ByteArray.empty leftClaimBytes allowed
+    (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[])
+  let nativeStructural := aggrCompiled.bytecode.executeIxAggr ixAggrIdx
+    (Aggr.pubInput allowed structuralClaimBytes)
+    (Aggr.structuralShapeCode .ixvm .ixvm)
+    leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk
+    leftIxvm.claimsBytes rightIxvm.claimsBytes structuralClaimBytes allowed
+    (Aggr.preimagesBlob #[leftClaimBytes, rightClaimBytes])
+    (Aggr.treesBlob structuralTrees) (Aggr.pathsBlob structuralPathAdvice)
+
+  -- Native keyed-blob framing is strict: even an otherwise honest pair must
+  -- reject a preimage blob that omits its u32 entry count.
+  let malformedNativeFraming := aggrCompiled.bytecode.executeIxAggr ixAggrIdx
+    (Aggr.pubInput allowed outputClaimBytes) (pairShape .ixvm .ixvm)
+    leftIxvm.proofAdviceBytes rightIxvm.proofAdviceBytes ixvmVk aggrVk
+    leftIxvm.claimsBytes rightIxvm.claimsBytes outputClaimBytes allowed
+    ⟨#[]⟩ (Aggr.treesBlob adviceTrees) (Aggr.pathsBlob #[])
+
+  let structuralHostCorrect :=
+    structuralOutput.subjects.root ==
+      Ix.Merkle.nodeHash leftStatement.subjects.root rightStatement.subjects.root &&
+    structuralOutput.assumptions.map (·.leaves) == some #[d] &&
+    structuralPathAdvice.size == 3
+
+  -- A path that stops at the left child root never reaches the structural
+  -- output root.
+  let wrongRootPathAdvice := structuralPathAdvice.map fun (candidate, path?) =>
+    if candidate == a then
+      (candidate, leftStatement.subjects.merkleProof candidate)
+    else (candidate, path?)
+  let wrongRootPath := runStructural .ixvm .ixvm leftIxvm rightIxvm
+    (paths := wrongRootPathAdvice)
+
+  -- Alter one sibling while retaining a syntactically valid path.
+  let tamperedPathAdvice := structuralPathAdvice.map fun (candidate, path?) =>
+    if candidate == a then
+      match path? with
+      | some path => match path[0]? with
+        | some (_, side) => (candidate, some (path.set! 0 (e, side)))
+        | none => (candidate, path?)
+      | none => (candidate, path?)
+    else (candidate, path?)
+  let tamperedPath := runStructural .ixvm .ixvm leftIxvm rightIxvm
+    (paths := tamperedPathAdvice)
+
+  -- Every candidate requires an explicit keyed choice; there is no implicit
+  -- carry default.
+  let droppedPathAdvice := structuralPathAdvice.filter fun (candidate, _) =>
+    candidate != d
+  let droppedPath := runStructural .ixvm .ixvm leftIxvm rightIxvm
+    (paths := droppedPathAdvice)
+
+  -- Candidate d chooses carry, but this output omits it.
+  let missingCarriedOutput : Aggr.CheckEnvTrees :=
+    { subjects := structuralOutput.subjects, assumptions := none }
+  let missingCarriedBytes := Ix.Claim.ser missingCarriedOutput.claim
+  let missingCarried := run (Aggr.structuralShapeCode .ixvm .ixvm)
+    #[leftIxvm, rightIxvm] missingCarriedBytes
+    (outClaim? := some missingCarriedBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.structuralAdviceTrees
+      leftStatement rightStatement missingCarriedOutput)
+    (paths := Aggr.CheckEnvTrees.structuralPathAdvice
+      leftStatement rightStatement missingCarriedOutput)
+
+  -- The same child statements cannot switch between flat and structural
+  -- semantics merely by changing the shape hint: each arm binds a different
+  -- output root equation.
+  let structuralHintOnFlatOutput := run
+    (Aggr.structuralShapeCode .ixvm .ixvm) #[leftIxvm, rightIxvm]
+    outputClaimBytes (outClaim? := some outputClaimBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := structuralTrees) (paths := structuralPathAdvice)
+  let flatHintOnStructuralOutput := run (pairShape .ixvm .ixvm)
+    #[leftIxvm, rightIxvm] structuralClaimBytes
+    (outClaim? := some structuralClaimBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.adviceTrees
+      leftStatement rightStatement structuralOutput)
+
+  -- A flat parent must reopen every subject as a canonical tree. Feeding it
+  -- a genuinely structural child therefore rejects, while the structural
+  -- parent above accepts the same child root opaquely.
+  let flatAfterStructuralOutput := structuralOutput.join rightStatement
+  let flatAfterStructuralBytes := Ix.Claim.ser flatAfterStructuralOutput.claim
+  let flatFedStructuralChild := run (pairShape .aggr .ixvm)
+    #[structuralSelf, rightIxvm] flatAfterStructuralBytes
+    (outClaim? := some flatAfterStructuralBytes)
+    (preimages := #[structuralClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.adviceTrees
+      structuralOutput rightStatement flatAfterStructuralOutput)
+
+  -- ── negative cases — one broken binding each ────────────────────────────
+  -- Shape hint lies about the child's system: a self proof cannot verify
+  -- against the IxVM vk the hinted kind binds.
+  let shapeLie := run (Aggr.shapeCode (.ixvm, none)) #[leftSelf] leftClaimBytes
+  -- Tampered proof advice.
+  let tamperedBytes := leftIxvm.proofAdviceBytes.set! 0
+    (UInt8.ofNat ((leftIxvm.proofAdviceBytes.data[0]!.toNat + 1) % 256))
+  let tampered := run (Aggr.shapeCode (.ixvm, none))
+    #[{ leftIxvm with proofAdviceBytes := tamperedBytes }] leftClaimBytes
+  -- A self child minted under a FOREIGN aggregation identity (different
+  -- entrypoint index) must not be joinable under this one.
+  let foreignAllowed := Aggr.allowedBlob ixvmVk fakeVerifyIdx aggrVk
+    (fakeAggrIdx + 1)
+  let foreignSelf ← match mkSelfChild foreignAllowed leftClaimBytes with
+    | .error e => IO.eprintln s!"foreign self proof advice encoding failed: {e}"; return 1
+    | .ok child => pure child
+  let foreignIdentity := run (Aggr.shapeCode (.aggr, none)) #[foreignSelf]
+    leftClaimBytes
+  -- Wrap must pass the child statement through unchanged.
+  let wrapMismatch := run (Aggr.shapeCode (.ixvm, none)) #[leftIxvm]
+    rightClaimBytes
+  -- A pair fold that drops the outstanding assumption {d}.
+  let droppedStatement : Aggr.CheckEnvTrees :=
+    { outputStatement with assumptions := none }
+  let droppedBytes := Ix.Claim.ser droppedStatement.claim
+  let droppedAssumption := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm]
+    droppedBytes (outClaim? := some droppedBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.adviceTrees
+      leftStatement rightStatement droppedStatement)
+  -- A pair fold whose output subjects contain an extra address {e}.
+  let paddedStatement : Aggr.CheckEnvTrees :=
+    { subjects := canonicalTree #[a, b, c, e]
+      assumptions := outputStatement.assumptions }
+  let paddedBytes := Ix.Claim.ser paddedStatement.claim
+  let extraSubject := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm]
+    paddedBytes (outClaim? := some paddedBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.adviceTrees
+      leftStatement rightStatement paddedStatement)
+  -- Tree advice whose leaves do not reproduce the keyed root: seed the
+  -- output-subject slot with the padded tree's serialization under the honest
+  -- root's key. The circuit recomputes the canonical root from the leaves.
+  let mismatchedIO := Id.run do
+    let mut io := mkIO allowed (pairShape .ixvm .ixvm) ixvmVk aggrVk
+      #[leftIxvm, rightIxvm] (outClaim? := some outputClaimBytes)
+      (preimages := #[leftClaimBytes, rightClaimBytes])
+      (trees := #[leftStatement.subjects, leftStatement.assumptions.get!,
+        rightStatement.subjects, rightStatement.assumptions.get!,
+        outputStatement.assumptions.get!])
+    io := io.extend 5 (Aggr.byteGs outputStatement.subjects.root.hash)
+      (Aggr.byteGs (Ix.AssumptionTree.ser paddedStatement.subjects))
+    return io
+  let mismatchedTree := aggrCompiled.bytecode.execute ixAggrIdx
+    (Aggr.pubInput allowed outputClaimBytes) mismatchedIO
+
+  -- A self-consistent free-form tree with descending leaves is not a
+  -- canonical set tree, even when its root matches the public output claim.
+  let sortedOutputLeaves := (#[a, b, c]).qsort fun x y => compare x y == .lt
+  let unsortedSubjects : Ix.AssumptionTree :=
+    .node (.node (.leaf sortedOutputLeaves[2]!) (.leaf sortedOutputLeaves[1]!))
+      (.leaf sortedOutputLeaves[0]!)
+  let unsortedStatement : Aggr.CheckEnvTrees := {
+    subjects := unsortedSubjects
+    assumptions := outputStatement.assumptions
+  }
+  let unsortedBytes := Ix.Claim.ser unsortedStatement.claim
+  let unsorted := run (pairShape .ixvm .ixvm) #[leftIxvm, rightIxvm]
+    unsortedBytes (outClaim? := some unsortedBytes)
+    (preimages := #[leftClaimBytes, rightClaimBytes])
+    (trees := Aggr.CheckEnvTrees.adviceTrees
+      leftStatement rightStatement unsortedStatement)
+
+  -- Identity framing and shape dispatch are closed: shortened blobs and
+  -- out-of-range shape bytes cannot select a permissive arm.
+  let shortAllowed := allowed.extract 0 72
+  let shortIdentity := aggrCompiled.bytecode.execute ixAggrIdx
+    (Aggr.pubInput shortAllowed leftClaimBytes)
+    (mkIO shortAllowed (Aggr.shapeCode (.ixvm, none)) ixvmVk aggrVk
+      #[leftIxvm])
+  let invalidShape := run 10 #[leftIxvm] leftClaimBytes
+
+  lspecIO (.ofList [("ix-aggr", [
+    test "ixAggr prunes the Ix-agnostic lift entrypoint" liftPruned,
+    test "pair fold leaves exactly one outstanding assumption"
+      (outputStatement.assumptions.map (·.leaves) == some #[d]),
+    test "structural fold is nodeHash(left,right) with one carried assumption"
+      structuralHostCorrect,
+    test "production wrap-first policy selects shapes 0, 5, and 9"
+      wrapFirstShapes,
+    test "direct-join policy selects raw leaves plus shapes 2 and 8"
+      directShapes,
+    test "direct mode still wraps a singleton root" singletonStillWraps,
+    test "M1-f wrap-first plan is shapes 0x4 then 9x3" m1fWrapShapes,
+    test "M1-f direct plan is raw leaves then shapes 6, 6, and 9"
+      m1fDirectShapes,
+    test "scheduler RAM weights follow the selected ix_aggr shapes"
+      shapeWeightsBounded,
+    test "driver specs use uniform aggregate claims and cache version 2"
+      uniformDriverClaims,
+    expectOk "wrap of an IxVM child accepts" wrapIxvm,
+    expectOk "wrap of a self child accepts" wrapSelf,
+    expectOk "pair (IxVM, IxVM) accepts" pairII,
+    expectOk "pair (IxVM, self) accepts" pairIA,
+    expectOk "pair (self, IxVM) accepts" pairAI,
+    expectOk "pair (self, self) accepts" pairAA,
+    expectOk "structural pair (IxVM, IxVM) accepts" structuralII,
+    expectOk "structural pair (IxVM, self) accepts" structuralIA,
+    expectOk "structural pair (self, IxVM) accepts" structuralAI,
+    expectOk "structural pair (self, self) accepts" structuralAA,
+    expectOk "structural parent accepts a structural self child"
+      nestedStructural,
+    test "codegen'd pair matches interpreter (output + query counts)"
+      (sameCounts nativePair pairII),
+    test "codegen'd wrap matches interpreter (output + query counts)"
+      (sameCounts nativeWrap wrapIxvm),
+    test "codegen'd structural pair matches interpreter (output + query counts)"
+      (sameCounts nativeStructural structuralII),
+    expectErr "shape hint lying about the child system is rejected" shapeLie,
+    expectErr "tampered proof advice is rejected" tampered,
+    expectErr "self child under a foreign identity is rejected" foreignIdentity,
+    expectErr "wrap output differing from the child statement is rejected"
+      wrapMismatch,
+    expectErr "pair output dropping an assumption is rejected" droppedAssumption,
+    expectErr "pair output with an extra subject is rejected" extraSubject,
+    expectErr "tree advice not reproducing its keyed root is rejected"
+      mismatchedTree,
+    expectErr "flat pair rejects a self-consistent unsorted subject tree"
+      unsorted,
+    expectErr "native pair rejects malformed keyed-blob framing"
+      malformedNativeFraming,
+    expectErr "ix_aggr rejects a shortened identity blob" shortIdentity,
+    expectErr "ix_aggr rejects an out-of-range shape hint" invalidShape,
+    expectErr "structural pair rejects a path to the wrong root" wrongRootPath,
+    expectErr "structural pair rejects a tampered path sibling" tamperedPath,
+    expectErr "structural pair rejects a missing path choice" droppedPath,
+    expectErr "structural pair rejects an omitted carried assumption"
+      missingCarried,
+    expectErr "structural shape hint rejects a flat output root"
+      structuralHintOnFlatOutput,
+    expectErr "flat shape hint rejects a structural output root"
+      flatHintOnStructuralOutput,
+    expectErr "flat pair rejects a genuinely structural child subject root"
+      flatFedStructuralChild,
+  ])]) []
+
+end Tests.Aggr
+
+end
diff --git a/Tests/AggrActivation.lean b/Tests/AggrActivation.lean
new file mode 100644
index 000000000..adc843fed
--- /dev/null
+++ b/Tests/AggrActivation.lean
@@ -0,0 +1,554 @@
+module
+
+public import Tests.Aggr
+
+/-!
+# `ix_aggr` activation audit
+
+M1-e replaces the pre-convergence lift/flat/structural-entrypoint audit with
+an audit of the one production `ix_aggr` entrypoint and all ten verified shape
+arms. The deterministic matrix crosses:
+
+* two controlled child trace heights;
+* wrap shapes 0–1;
+* pair shapes 2–9;
+* optional assumptions independently on the left and right; and
+* assumptions that are either discharged by the other subject tree or carried
+  into the output.
+
+That produces 4 wrap executions plus 128 pair executions. The runner executes
+the complete 132-case matrix twice through the generated native path, compares
+every per-circuit query count, and emits a Markdown report. It records
+activation only; dummy-call policy remains deferred until a static terminal is
+selected.
+-/
+
+public section
+
+open Aiur
+
+namespace Tests.Aggr
+namespace ActivationAudit
+
+inductive Height where
+  | short
+  | tall
+  deriving BEq, Repr
+
+private def Height.label : Height → String
+  | .short => "short"
+  | .tall => "tall"
+
+inductive ChildKind where
+  | ixvm
+  | aggr
+  deriving BEq, Repr
+
+private def ChildKind.label : ChildKind → String
+  | .ixvm => "ixvm"
+  | .aggr => "aggr"
+
+private def ChildKind.shapeCode : ChildKind → Nat
+  | .ixvm => 0
+  | .aggr => 1
+
+inductive Disposition where
+  | discharge
+  | carry
+  deriving BEq, Repr
+
+private def Disposition.label : Disposition → String
+  | .discharge => "discharge"
+  | .carry => "carry"
+
+/-- Cheap parameters are sufficient here: the audit studies which verifier
+circuits execute, not production soundness calibration or proof size. -/
+private def auditFri : Aiur.FriParameters :=
+  { logFinalPolyLen := 0, maxLogArity := 1, numQueries := 1,
+    commitProofOfWorkBits := 0, queryProofOfWorkBits := 0 }
+
+/-- The two fake child entrypoints have the exact public-claim layouts accepted
+by `ix_aggr`. Both vary their trace height from the output-claim digest, letting
+one statement fixture drive the same height through either child kind. -/
+private def childProgram : Source.Toplevel := ⟦
+  fn activation_height_probe(n: G) {
+    match n {
+      0 => (),
+      _ => activation_height_probe(n - 1),
+    }
+  }
+
+  fn activation_vary_height(digest: [G; 8]) {
+    match u32_less_than(digest[0], digest[1]) {
+      1 => activation_height_probe(1),
+      _ => activation_height_probe(4),
+    }
+  }
+
+  pub fn fake_verify_claim(digest: [G; 8]) {
+    activation_vary_height(digest)
+  }
+
+  pub fn fake_aggr(allowed_digest: [G; 8], out_claim_digest: [G; 8]) {
+    activation_vary_height(out_claim_digest);
+    assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]);
+    ()
+  }
+⟧
+
+private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree :=
+  (Ix.AssumptionTree.canonical leaves).get!
+
+private def digestSelectsShort (digest : Array Aiur.G) : Bool :=
+  match digest[0]?, digest[1]? with
+  | some a, some b => decide (a.n < b.n)
+  | _, _ => false
+
+private structure Indices where
+  verify : Aiur.Bytecode.FunIdx
+  aggr : Aiur.Bytecode.FunIdx
+
+private structure Fixture where
+  height : Height
+  salt : Nat
+  leftNone : Aggr.CheckEnvTrees
+  leftDischarge : Aggr.CheckEnvTrees
+  leftCarry : Aggr.CheckEnvTrees
+  rightNone : Aggr.CheckEnvTrees
+  rightDischarge : Aggr.CheckEnvTrees
+  rightCarry : Aggr.CheckEnvTrees
+
+private def fixtureAt (height : Height) (salt : Nat) : Fixture :=
+  let address (side : String) :=
+    Address.blake3 (s!"ix-aggr-activation-{salt}-{side}").toUTF8
+  let a := address "subject-left"
+  let b := address "subject-right"
+  let c := address "carry-left"
+  let d := address "carry-right"
+  let leftSubjects := canonicalTree #[a]
+  let rightSubjects := canonicalTree #[b]
+  {
+    height
+    salt
+    leftNone := { subjects := leftSubjects, assumptions := none }
+    leftDischarge := {
+      subjects := leftSubjects, assumptions := some (canonicalTree #[b]) }
+    leftCarry := {
+      subjects := leftSubjects, assumptions := some (canonicalTree #[c]) }
+    rightNone := { subjects := rightSubjects, assumptions := none }
+    rightDischarge := {
+      subjects := rightSubjects, assumptions := some (canonicalTree #[a]) }
+    rightCarry := {
+      subjects := rightSubjects, assumptions := some (canonicalTree #[d]) }
+  }
+
+private def Fixture.statements (fixture : Fixture) : Array Aggr.CheckEnvTrees :=
+  #[fixture.leftNone, fixture.leftDischarge, fixture.leftCarry,
+    fixture.rightNone, fixture.rightDischarge, fixture.rightCarry]
+
+/-- Find six related statements whose claim digests all select the requested
+height branch. The expected search is 64 salts; the generous bound keeps the
+fixture deterministic without baking opaque addresses into the source. -/
+private def findFixture (height : Height) : Except String Fixture := do
+  let wantShort := height == .short
+  let some salt := (Array.range 65536).find? fun salt =>
+      let fixture := fixtureAt height salt
+      fixture.statements.all fun statement =>
+        digestSelectsShort (Aggr.digestGs (Ix.Claim.ser statement.claim)) ==
+          wantShort
+    | throw s!"activation audit: no {height.label} statement fixture found"
+  pure (fixtureAt height salt)
+
+private structure HeightConfig where
+  fixture : Fixture
+  probeRows : Nat
+
+private def prepareHeightConfig (compiled : Aiur.CompiledToplevel)
+    (indices : Indices) (probeIdx : Aiur.Bytecode.FunIdx) (height : Height) :
+    Except String HeightConfig := do
+  let fixture ← findFixture height
+  let input := Aggr.digestGs (Ix.Claim.ser fixture.leftNone.claim)
+  let (_, _, counts) ← compiled.bytecode.execute indices.verify input default
+  let some count := counts[probeIdx]?
+    | throw s!"activation audit: missing height-probe query count {probeIdx}"
+  pure { fixture, probeRows := count.uniqueRows }
+
+private def selectStatement (withoutAsm discharge carry : Aggr.CheckEnvTrees)
+    (present : Bool) (disposition : Disposition) : Aggr.CheckEnvTrees :=
+  if !present then withoutAsm
+  else match disposition with
+    | .discharge => discharge
+    | .carry => carry
+
+private def assumptionLabel (present : Bool) : String :=
+  if present then "some" else "none"
+
+private structure PreparedChild where
+  proofAdviceBytes : ByteArray
+  claimsBytes : ByteArray
+
+private def prepareChild (ixvmSystem selfSystem : Aiur.AiurSystem)
+    (indices : Indices) (allowed : ByteArray) (kind : ChildKind)
+    (statement : Aggr.CheckEnvTrees) : Except String PreparedChild := do
+  let claimBytes := Ix.Claim.ser statement.claim
+  let (system, idx, input) := match kind with
+    | .ixvm => (ixvmSystem, indices.verify, Aggr.digestGs claimBytes)
+    | .aggr => (selfSystem, indices.aggr, Aggr.pubInput allowed claimBytes)
+  let (outer, proof, _) ← system.prove idx input default
+  let proofAdviceBytes ← system.proofToAdviceBytes outer proof
+  pure {
+    proofAdviceBytes
+    claimsBytes := MultiStark.serializeClaims #[outer]
+  }
+
+private structure PairShape where
+  shape : Nat
+  structural : Bool
+  leftKind : ChildKind
+  rightKind : ChildKind
+
+private def pairShapes : Array PairShape := #[
+  { shape := 2, structural := false, leftKind := .ixvm, rightKind := .ixvm },
+  { shape := 3, structural := false, leftKind := .ixvm, rightKind := .aggr },
+  { shape := 4, structural := false, leftKind := .aggr, rightKind := .ixvm },
+  { shape := 5, structural := false, leftKind := .aggr, rightKind := .aggr },
+  { shape := 6, structural := true, leftKind := .ixvm, rightKind := .ixvm },
+  { shape := 7, structural := true, leftKind := .ixvm, rightKind := .aggr },
+  { shape := 8, structural := true, leftKind := .aggr, rightKind := .ixvm },
+  { shape := 9, structural := true, leftKind := .aggr, rightKind := .aggr }
+]
+
+private structure WrapCase where
+  label : String
+  shape : Nat
+  statement : Aggr.CheckEnvTrees
+  child : PreparedChild
+
+private structure PairCase where
+  label : String
+  pair : PairShape
+  left : Aggr.CheckEnvTrees
+  right : Aggr.CheckEnvTrees
+  leftChild : PreparedChild
+  rightChild : PreparedChild
+
+private def prepareWrapCases (ixvmSystem selfSystem : Aiur.AiurSystem)
+    (indices : Indices) (allowed : ByteArray)
+    (configs : Array HeightConfig) : Except String (Array WrapCase) := do
+  let mut cases : Array WrapCase := #[]
+  for config in configs do
+    for kind in #[ChildKind.ixvm, .aggr] do
+      let child ← prepareChild ixvmSystem selfSystem indices allowed kind
+        config.fixture.leftNone
+      cases := cases.push {
+        label := s!"shape={kind.shapeCode},height={config.fixture.height.label},\
+          child={kind.label}"
+        shape := kind.shapeCode
+        statement := config.fixture.leftNone
+        child
+      }
+  pure cases
+
+private def preparePairCases (ixvmSystem selfSystem : Aiur.AiurSystem)
+    (indices : Indices) (allowed : ByteArray)
+    (configs : Array HeightConfig) : Except String (Array PairCase) := do
+  let mut cases : Array PairCase := #[]
+  for config in configs do
+    let fixture := config.fixture
+    for disposition in #[Disposition.discharge, .carry] do
+      for leftAsm in #[false, true] do
+        for rightAsm in #[false, true] do
+          let left := selectStatement fixture.leftNone fixture.leftDischarge
+            fixture.leftCarry leftAsm disposition
+          let right := selectStatement fixture.rightNone fixture.rightDischarge
+            fixture.rightCarry rightAsm disposition
+          for pair in pairShapes do
+            let leftChild ← prepareChild ixvmSystem selfSystem indices allowed
+              pair.leftKind left
+            let rightChild ← prepareChild ixvmSystem selfSystem indices allowed
+              pair.rightKind right
+            cases := cases.push {
+              label := s!"shape={pair.shape},height={fixture.height.label},\
+                left-asm={assumptionLabel leftAsm},\
+                right-asm={assumptionLabel rightAsm},\
+                disposition={disposition.label},\
+                children={pair.leftKind.label}+{pair.rightKind.label}"
+              pair
+              left
+              right
+              leftChild
+              rightChild
+            }
+  pure cases
+
+private structure Sample where
+  label : String
+  shape : Nat
+  queryCounts : Array Aiur.QueryCount
+
+private def runWrap (compiled : Aiur.CompiledToplevel)
+    (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray)
+    (case : WrapCase) : Except String Sample := do
+  let claimBytes := Ix.Claim.ser case.statement.claim
+  let (_, queryCounts) ← match compiled.bytecode.executeIxAggr idx
+      (Aggr.pubInput allowed claimBytes) case.shape
+      case.child.proofAdviceBytes ByteArray.empty ixvmVk selfVk
+      case.child.claimsBytes ByteArray.empty claimBytes allowed
+      (Aggr.preimagesBlob #[]) (Aggr.treesBlob #[]) (Aggr.pathsBlob #[]) with
+    | .ok result => pure result
+    | .error e => throw s!"{case.label}: {e}"
+  pure { label := case.label, shape := case.shape, queryCounts }
+
+private def runPair (compiled : Aiur.CompiledToplevel)
+    (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray)
+    (case : PairCase) : Except String Sample := do
+  let output := if case.pair.structural then
+    case.left.joinStructural case.right
+  else
+    case.left.join case.right
+  let trees := if case.pair.structural then
+    Aggr.CheckEnvTrees.structuralAdviceTrees case.left case.right output
+  else
+    Aggr.CheckEnvTrees.adviceTrees case.left case.right output
+  let paths := if case.pair.structural then
+    Aggr.CheckEnvTrees.structuralPathAdvice case.left case.right output
+  else #[]
+  let leftBytes := Ix.Claim.ser case.left.claim
+  let rightBytes := Ix.Claim.ser case.right.claim
+  let outputBytes := Ix.Claim.ser output.claim
+  let (_, queryCounts) ← match compiled.bytecode.executeIxAggr idx
+      (Aggr.pubInput allowed outputBytes) case.pair.shape
+      case.leftChild.proofAdviceBytes case.rightChild.proofAdviceBytes
+      ixvmVk selfVk case.leftChild.claimsBytes case.rightChild.claimsBytes
+      outputBytes allowed (Aggr.preimagesBlob #[leftBytes, rightBytes])
+      (Aggr.treesBlob trees) (Aggr.pathsBlob paths) with
+    | .ok result => pure result
+    | .error e => throw s!"{case.label}: {e}"
+  pure { label := case.label, shape := case.pair.shape, queryCounts }
+
+private def collect (compiled : Aiur.CompiledToplevel)
+    (idx : Aiur.Bytecode.FunIdx) (ixvmVk selfVk allowed : ByteArray)
+    (wrapCases : Array WrapCase) (pairCases : Array PairCase) :
+    Except String (Array Sample) := do
+  let mut samples : Array Sample := #[]
+  for case in wrapCases do
+    samples := samples.push (← runWrap compiled idx ixvmVk selfVk allowed case)
+  for case in pairCases do
+    samples := samples.push (← runPair compiled idx ixvmVk selfVk allowed case)
+  pure samples
+
+private def queryCountsEq (left right : Array Aiur.QueryCount) : Bool :=
+  left.size == right.size && (left.zip right).all fun (a, b) =>
+    a.uniqueRows == b.uniqueRows && a.totalHits == b.totalHits
+
+private def samplesEq (left right : Array Sample) : Bool :=
+  left.size == right.size && (left.zip right).all fun (a, b) =>
+    a.label == b.label && a.shape == b.shape &&
+      queryCountsEq a.queryCounts b.queryCounts
+
+private structure Circuit where
+  name : String
+  queryIdx : Nat
+
+private def circuits (compiled : Aiur.CompiledToplevel) : Array Circuit := Id.run do
+  let reverseNames := compiled.nameMap.fold
+    (init := ({} : Std.HashMap Aiur.Bytecode.FunIdx String))
+    fun names global idx =>
+      let name := toString global
+      match names[idx]? with
+      | none => names.insert idx name
+      | some old => if compare name old == .lt then names.insert idx name else names
+  let mut result : Array Circuit := #[]
+  for (function, idx) in compiled.bytecode.functions.mapIdx
+      fun idx function => (function, idx) do
+    if function.constrained then
+      result := result.push {
+        name := reverseNames[idx]?.getD s!"fn[{idx}]"
+        queryIdx := idx
+      }
+  let functionCount := compiled.bytecode.functions.size
+  for (width, idx) in compiled.bytecode.memorySizes.mapIdx fun idx width =>
+      (width, idx) do
+    result := result.push {
+      name := s!"memory[{width}]"
+      queryIdx := functionCount + idx
+    }
+  pure result
+
+private structure Cell where
+  active : Nat
+  total : Nat
+  minActiveRows : Nat
+  maxActiveRows : Nat
+
+private def rowsAt (sample : Sample) (queryIdx : Nat) : Nat :=
+  match sample.queryCounts[queryIdx]? with
+  | some count => count.uniqueRows
+  | none => 0
+
+private def cell (samples : Array Sample) (queryIdx : Nat) : Cell :=
+  let activeRows := samples.map (rowsAt · queryIdx) |>.filter (· != 0)
+  let minActiveRows := match activeRows[0]? with
+    | none => 0
+    | some first => activeRows.foldl Nat.min first
+  {
+    active := activeRows.size
+    total := samples.size
+    minActiveRows
+    maxActiveRows := activeRows.foldl Nat.max 0
+  }
+
+private def Cell.render (summary : Cell) : String :=
+  if summary.active == 0 then s!"0/{summary.total}"
+  else s!"{summary.active}/{summary.total} \
+    ({summary.minActiveRows}..{summary.maxActiveRows})"
+
+private def shapeSamples (samples : Array Sample) (shape : Nat) : Array Sample :=
+  samples.filter fun sample => sample.shape == shape
+
+private def activationSignature (samples : Array Sample) : Address :=
+  let lines := samples.map fun sample =>
+    let counts := sample.queryCounts.map fun count =>
+      s!"{count.uniqueRows}/{count.totalHits}"
+    sample.label ++ ":" ++ String.intercalate "," counts.toList
+  Address.blake3 (String.intercalate "\n" lines.toList).toUTF8
+
+private def report (compiled : Aiur.CompiledToplevel)
+    (configs : Array HeightConfig) (samples : Array Sample) : String :=
+  let catalog := circuits compiled
+  let affected := catalog.filter fun circuit =>
+    let summary := cell samples circuit.queryIdx
+    summary.active < summary.total
+  let alwaysActive := catalog.countP fun circuit =>
+    (cell samples circuit.queryIdx).active == samples.size
+  let variableCount := catalog.countP fun circuit =>
+    let summary := cell samples circuit.queryIdx
+    summary.active != 0 && summary.active < summary.total
+  let neverObserved := catalog.countP fun circuit =>
+    (cell samples circuit.queryIdx).active == 0
+  let shapeCounts := (Array.range 10).map fun shape =>
+    s!"shape {shape}: {(shapeSamples samples shape).size}"
+  let configRows := configs.map fun config =>
+    s!"| {config.fixture.height.label} | {config.fixture.salt} | \
+      {config.probeRows} |"
+  let tableHeader := "| Circuit | " ++
+    String.intercalate " | " ((Array.range 10).map fun shape =>
+      s!"Shape {shape}").toList ++ " |"
+  let tableDivider := "|---|" ++
+    String.intercalate "" ((Array.range 10).map fun _ => "---:|").toList
+  let circuitRows := affected.map fun circuit =>
+    let cells := (Array.range 10).map fun shape =>
+      (cell (shapeSamples samples shape) circuit.queryIdx).render
+    s!"| `{circuit.name}` | {String.intercalate " | " cells.toList} |"
+  let introduction := #[]
+    |>.push "# `ix_aggr` activation audit"
+    |>.push ""
+    |>.push s!"- Matrix signature: `{activationSignature samples}`"
+    |>.push s!"- Accepted executions: {samples.size} \
+      ({String.intercalate ", " shapeCounts.toList})"
+    |>.push "- Axes: two child trace heights; both wrap shapes; every flat and \
+      structural child-kind shape; assumption root `{none,some}` independently \
+      per side; and `{discharge,carry}`."
+    |>.push "- Counts are `active cases / total cases (min..max unique rows when active)`."
+    |>.push "- Catalog covers constrained function circuits and memory circuits. \
+      `Bytes1`/`Bytes2` are fixed-height preprocessed circuits and are not \
+      represented in the execute FFI's query-count array."
+    |>.push s!"- Catalog summary: {catalog.size} circuits; {alwaysActive} active \
+      in every case; {variableCount} input-dependent; {neverObserved} never observed."
+    |>.push "- Dummy calls remain deferred until a static terminal circuit is selected."
+    |>.push ""
+    |>.push "## Trace-height control"
+    |>.push ""
+    |>.push "| Height | Fixture salt | `activation_height_probe` unique rows |"
+    |>.push "|---|---:|---:|"
+  let circuitHeader := (introduction ++ configRows)
+    |>.push ""
+    |>.push "## Circuits inactive in at least one audited shape"
+    |>.push ""
+    |>.push tableHeader
+    |>.push tableDivider
+  String.intercalate "\n" (circuitHeader ++ circuitRows).toList
+
+def run : IO UInt32 := do
+  IO.println "aggregate-activation (132-case ix_aggr matrix, two deterministic passes)…"
+  let childCompiled ← match childProgram.compile with
+    | .error e => IO.eprintln s!"activation child compilation failed: {e}"; return 1
+    | .ok compiled => pure compiled
+  let some verifyIdx := childCompiled.getFuncIdx `fake_verify_claim | do
+    IO.eprintln "activation audit: fake_verify_claim entrypoint not found"; return 1
+  let some fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr | do
+    IO.eprintln "activation audit: fake_aggr entrypoint not found"; return 1
+  let some probeIdx := childCompiled.getFuncIdx `activation_height_probe | do
+    IO.eprintln "activation audit: height probe not found"; return 1
+  let indices : Indices := { verify := verifyIdx, aggr := fakeAggrIdx }
+  let ixvmSystem := Aiur.AiurSystem.build childCompiled.bytecode
+    Tests.MultiStark.recCommitParams auditFri
+  let selfSystem := Aiur.AiurSystem.build childCompiled.bytecode
+    Tests.MultiStark.recCommitParams { auditFri with numQueries := 2 }
+  let ixvmVk := ixvmSystem.vkBytes
+  let selfVk := selfSystem.vkBytes
+  let allowed := Aggr.allowedBlob ixvmVk verifyIdx selfVk fakeAggrIdx
+
+  let short ← match prepareHeightConfig childCompiled indices probeIdx .short with
+    | .error e => IO.eprintln e; return 1
+    | .ok config => pure config
+  let tall ← match prepareHeightConfig childCompiled indices probeIdx .tall with
+    | .error e => IO.eprintln e; return 1
+    | .ok config => pure config
+  if short.probeRows >= tall.probeRows then
+    IO.eprintln s!"activation audit: height controls did not vary the trace \
+      ({short.probeRows} vs {tall.probeRows} rows)"
+    return 1
+  let configs := #[short, tall]
+  let wrapCases ← match prepareWrapCases ixvmSystem selfSystem indices allowed configs with
+    | .error e => IO.eprintln s!"activation wrap preparation failed: {e}"; return 1
+    | .ok cases => pure cases
+  let pairCases ← match preparePairCases ixvmSystem selfSystem indices allowed configs with
+    | .error e => IO.eprintln s!"activation pair preparation failed: {e}"; return 1
+    | .ok cases => pure cases
+  if wrapCases.size != 4 || pairCases.size != 128 then
+    IO.eprintln s!"activation audit: expected 4 wraps + 128 pairs, built \
+      {wrapCases.size} + {pairCases.size}"
+    return 1
+
+  let top ← match Aggr.ixAggr with
+    | .error e => IO.eprintln s!"activation toplevel merge failed: {e}"; return 1
+    | .ok top => pure top
+  let compiled ← match top.compile with
+    | .error e => IO.eprintln s!"activation toplevel compilation failed: {e}"; return 1
+    | .ok compiled => pure compiled
+  let some ixAggrIdx := compiled.getFuncIdx `ix_aggr | do
+    IO.eprintln "activation audit: ix_aggr entrypoint not found"; return 1
+
+  let first ← match collect compiled ixAggrIdx ixvmVk selfVk allowed
+      wrapCases pairCases with
+    | .error e => IO.eprintln s!"activation audit pass 1 failed: {e}"; return 1
+    | .ok samples => pure samples
+  let second ← match collect compiled ixAggrIdx ixvmVk selfVk allowed
+      wrapCases pairCases with
+    | .error e => IO.eprintln s!"activation audit pass 2 failed: {e}"; return 1
+    | .ok samples => pure samples
+  if first.size != 132 then
+    IO.eprintln s!"activation audit: expected 132 samples, collected {first.size}"
+    return 1
+  let expectedQueryCounts := compiled.bytecode.functions.size +
+    compiled.bytecode.memorySizes.size
+  if first.any fun sample => sample.queryCounts.size != expectedQueryCounts then
+    IO.eprintln s!"activation audit: a sample returned the wrong query-count \
+      cardinality (expected {expectedQueryCounts})"
+    return 1
+  if !samplesEq first second then
+    IO.eprintln "activation audit: query-count matrix changed between passes"
+    return 1
+  IO.println (report compiled configs first)
+  IO.println ""
+  IO.println "[activation-audit] stable across two passes"
+  return 0
+
+end ActivationAudit
+
+def activationAudit : IO UInt32 := ActivationAudit.run
+
+end Tests.Aggr
+
+end
diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean
new file mode 100644
index 000000000..752b1e73f
--- /dev/null
+++ b/Tests/AggrSemantics.lean
@@ -0,0 +1,640 @@
+module
+
+public import Tests.Aggr
+
+/-!
+# Converged aggregate host/driver semantics
+
+M1-e ports the host, manifest, cache, verifier-value, and scheduler coverage
+that originally lived beside the three-entrypoint aggregate circuit onto the
+production `ix_aggr` claim and slot model. Circuit shape positives/negatives
+remain in `Tests/Aggr.lean`; this file supplies the rest of the semantic union.
+-/
+
+public section
+
+open LSpec Aiur
+
+namespace Tests.Aggr
+
+open Tests.MultiStark (expectOk expectErr recCommitParams innerFri u64le)
+
+private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree :=
+  (Ix.AssumptionTree.canonical leaves).get!
+
+private def u32le4 (n : Nat) : Array UInt8 :=
+  (Array.range 4).map fun i => UInt8.ofNat ((n >>> (8 * i)) % 256)
+
+private def minimalIxesFor (shards : Array (Array Address))
+    (treeTail : Array UInt8) : ByteArray :=
+  let putAddresses := fun (addresses : Array Address) =>
+    addresses.foldl (fun out address => out ++ address.hash.data)
+      (u32le4 addresses.size)
+  let shard := fun id blocks => u32le4 id ++ Array.replicate 24 0 ++ #[0] ++
+    putAddresses blocks ++ u32le4 0
+  let body := (shards.mapIdx shard).foldl (· ++ ·) #[]
+  ⟨#[0x49, 0x58, 0x45, 0x53, 0, 0, 0, 0] ++ Array.replicate 16 0 ++
+    u32le4 shards.size ++ body ++ treeTail⟩
+
+private def minimalIxes (treeTail : Array UInt8) : ByteArray :=
+  minimalIxesFor #[#[], #[]] treeTail
+
+private def singletonIxonEnv : Ixon.Env × Address :=
+  let constant : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let address := Address.blake3 (Ixon.serConstant constant)
+  (({} : Ixon.Env).storeConst address constant, address)
+
+private def pairIxonEnv : Ixon.Env × Address × Address :=
+  let left : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let right : Ixon.Constant :=
+    ⟨.axio ⟨true, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let leftAddress := Address.blake3 (Ixon.serConstant left)
+  let rightAddress := Address.blake3 (Ixon.serConstant right)
+  let env := (({} : Ixon.Env).storeConst leftAddress left)
+    |>.storeConst rightAddress right
+  (env, leftAddress, rightAddress)
+
+/-- Two owned constants with one shared dependency exercise the one-pass
+witness-closure union retained by the converged driver. -/
+private def sharedClosureIxonEnv : Ixon.Env × Array Address × Address :=
+  let shared : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let sharedAddress := Address.blake3 (Ixon.serConstant shared)
+  let left : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .ref 0 #[]⟩, #[], #[sharedAddress], #[]⟩
+  let right : Ixon.Constant :=
+    ⟨.axio ⟨true, 0, .ref 0 #[]⟩, #[], #[sharedAddress], #[]⟩
+  let leftAddress := Address.blake3 (Ixon.serConstant left)
+  let rightAddress := Address.blake3 (Ixon.serConstant right)
+  let env := (({} : Ixon.Env).storeConst sharedAddress shared)
+    |>.storeConst leftAddress left
+    |>.storeConst rightAddress right
+  (env, #[leftAddress, rightAddress], sharedAddress)
+
+def semanticSuite : IO UInt32 := do
+  let childCompiled ← match childProgram.compile with
+    | .error e => IO.eprintln s!"aggr semantic child compilation failed: {e}"; return 1
+    | .ok compiled => pure compiled
+  let verifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get!
+  let fakeAggrIdx := childCompiled.getFuncIdx `fake_aggr |>.get!
+  let ixvmSystem := AiurSystem.build childCompiled.bytecode recCommitParams innerFri
+  let selfSystem := AiurSystem.build childCompiled.bytecode recCommitParams
+    { innerFri with numQueries := 4 }
+  let ixvmVk := ixvmSystem.vkBytes
+  let selfVk := selfSystem.vkBytes
+  let allowed := Aggr.allowedBlob ixvmVk verifyIdx selfVk fakeAggrIdx
+
+  -- Recursion parameter and cache-key contract.
+  let recursionDefaults := MultiStark.defaultRecursionParameters
+  let defaultRecursionSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode recursionDefaults
+  let directDefaultSystem := AiurSystem.build childCompiled.bytecode
+    Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
+  let expectedDefaultFriBytes : ByteArray :=
+    ⟨u64le 0 ++ u64le 1 ++ u64le 100 ++ u64le 0 ++ u64le 20⟩
+  let tunedFri : Aiur.FriParameters :=
+    { recursionDefaults.fri with numQueries := 50 }
+  let tunedFriParameters : MultiStark.RecursionParameters :=
+    { recursionDefaults with fri := tunedFri }
+  let tunedFriSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode tunedFriParameters
+  let tunedCommitment : Aiur.CommitmentParameters :=
+    { recursionDefaults.commitment with logBlowup := 3 }
+  let tunedCommitmentParameters : MultiStark.RecursionParameters :=
+    { recursionDefaults with commitment := tunedCommitment }
+  let tunedCommitmentSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode tunedCommitmentParameters
+  let defaultRecursionIdentityPreserved :=
+    defaultRecursionSystem.vkBytes == directDefaultSystem.vkBytes
+  let defaultFriEncodingStable :=
+    recursionDefaults.cacheFriBytes.size == 40 &&
+      recursionDefaults.cacheFriBytes == expectedDefaultFriBytes
+  let recursionParametersIndependent :=
+    tunedFriParameters.cacheFriBytes != recursionDefaults.cacheFriBytes &&
+      tunedFriSystem.vkBytes != defaultRecursionSystem.vkBytes &&
+      tunedCommitmentParameters.cacheFriBytes == recursionDefaults.cacheFriBytes &&
+      tunedCommitmentSystem.vkBytes != defaultRecursionSystem.vkBytes
+
+  -- Two conditional statements whose assumptions cross the subject boundary.
+  let a := Address.blake3 "aggr-semantics-a".toUTF8
+  let b := Address.blake3 "aggr-semantics-b".toUTF8
+  let c := Address.blake3 "aggr-semantics-c".toUTF8
+  let d := Address.blake3 "aggr-semantics-d".toUTF8
+  let left : Aggr.CheckEnvTrees := {
+    subjects := canonicalTree #[a, b]
+    assumptions := some (canonicalTree #[c, d])
+  }
+  let right : Aggr.CheckEnvTrees := {
+    subjects := canonicalTree #[c]
+    assumptions := some (canonicalTree #[a])
+  }
+  let flatOutput := left.join right
+  let structuralOutput := left.joinStructural right
+  let flatHostCorrect :=
+    flatOutput.subjects.leaves == (canonicalTree #[a, b, c]).leaves &&
+      flatOutput.assumptions.map (·.leaves) == some #[d]
+  let structuralHostCorrect :=
+    structuralOutput.subjects.root ==
+      Ix.Merkle.nodeHash left.subjects.root right.subjects.root &&
+      structuralOutput.assumptions.map (·.leaves) == some #[d]
+  let converted := Ix.Cli.AggregateCmd.toAggrCheckEnvTrees
+    (Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees structuralOutput)
+  let hostConversionRoundTrip := converted.claim == structuralOutput.claim &&
+    converted.subjects.leaves == structuralOutput.subjects.leaves &&
+    converted.assumptions.map (·.leaves) ==
+      structuralOutput.assumptions.map (·.leaves)
+
+  let leftBytes := Ix.Claim.ser left.claim
+  let rightBytes := Ix.Claim.ser right.claim
+  let flatBytes := Ix.Claim.ser flatOutput.claim
+  let leftOuter := Ix.Cli.AggregateCmd.aggregateOuterClaim
+    allowed fakeAggrIdx left.claim
+  let rightOuter := Ix.Cli.AggregateCmd.aggregateOuterClaim
+    allowed fakeAggrIdx right.claim
+  let flatOuter := Ix.Cli.AggregateCmd.aggregateOuterClaim
+    allowed fakeAggrIdx flatOutput.claim
+  let (_, leftProof, _) ← match selfSystem.prove fakeAggrIdx
+      (Aggr.pubInput allowed leftBytes) default with
+    | .error e => IO.eprintln s!"left aggregate prove failed: {e}"; return 1
+    | .ok result => pure result
+  let (_, rightProof, _) ← match selfSystem.prove fakeAggrIdx
+      (Aggr.pubInput allowed rightBytes) default with
+    | .error e => IO.eprintln s!"right aggregate prove failed: {e}"; return 1
+    | .ok result => pure result
+  let outerClaimBindsValue := leftOuter != rightOuter &&
+    flatOuter == Aiur.buildClaim fakeAggrIdx (Aggr.pubInput allowed flatBytes) #[]
+
+  let childRecursionParameters : MultiStark.RecursionParameters := {
+    commitment := recCommitParams
+    fri := innerFri
+  }
+  let leftKey := Ix.Cli.AggregateCmd.aggregateCacheKey selfVk
+    childRecursionParameters leftOuter
+  let cacheKeyStable := leftKey == Ix.Cli.AggregateCmd.aggregateCacheKey
+    selfVk childRecursionParameters leftOuter
+  let cacheKeyBindsOuter := leftKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+    selfVk childRecursionParameters rightOuter
+  let cacheKeyBindsFri := leftKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+    selfVk { childRecursionParameters with fri := tunedFri } leftOuter
+  let cacheKeyBindsVk := leftKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+    (selfVk.set! 0 (selfVk.data[0]! + 1)) childRecursionParameters leftOuter
+  let cacheKeyBindsVersion := leftKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+    selfVk childRecursionParameters leftOuter 1
+  let repeated07 : Nat := 506381209866536711
+  let cacheVectorParameters : MultiStark.RecursionParameters := {
+    commitment := Aiur.defaultCommitmentParameters
+    fri := {
+      logFinalPolyLen := repeated07
+      maxLogArity := repeated07
+      numQueries := repeated07
+      commitProofOfWorkBits := repeated07
+      queryProofOfWorkBits := repeated07
+    }
+  }
+  let cacheKeyMatchesRustVector :=
+    toString (Ix.Cli.AggregateCmd.aggregateCacheKey "vk".toUTF8
+      cacheVectorParameters #[.ofNat 1, .ofNat 2, .ofNat 3]) ==
+      "86ed059157e2915fe0a83f1afd58f31f7553659ad778669f6b795e1473e7afe0"
+
+  let ops : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp :=
+    #[.leaf 0, .leaf 1, .join 0 1]
+  let wrapPlan := Ix.Cli.AggregateCmd.schedulePlan ops #[2, 1] 8
+  let directPlan := Ix.Cli.AggregateCmd.schedulePlan ops #[2, 1] 8 true
+  let prepared : Array Ix.Cli.AggregateCmd.PreparedShard := #[
+    { claim := left.claim,
+      statement := Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees left },
+    { claim := right.claim,
+      statement := Ix.Cli.AggregateCmd.fromAggrCheckEnvTrees right }
+  ]
+  let wrapSpecs := wrapPlan.bind fun plan =>
+    Ix.Cli.AggregateCmd.buildAggrSlotSpecs plan prepared selfVk allowed
+      verifyIdx fakeAggrIdx childRecursionParameters
+  let directSpecs := directPlan.bind fun plan =>
+    Ix.Cli.AggregateCmd.buildAggrSlotSpecs plan prepared selfVk allowed
+      verifyIdx fakeAggrIdx childRecursionParameters
+  let wrapSpecsComplete : Bool := match wrapSpecs with
+    | .ok specs => match specs[0]?, specs[1]?, specs[2]? with
+      | some leftSpec, some rightSpec, some rootSpec =>
+        specs.size == 3 && leftSpec.kind == .aggr && rightSpec.kind == .aggr &&
+          leftSpec.outerClaim == leftOuter && rightSpec.outerClaim == rightOuter &&
+          rootSpec.statement.claim == flatOutput.claim &&
+          rootSpec.outerClaim == flatOuter && leftSpec.cacheKey == leftKey
+      | _, _, _ => false
+    | .error _ => false
+  let directSpecsUseRawLeaves : Bool := match directSpecs with
+    | .ok specs => match specs[0]?, specs[1]?, specs[2]? with
+      | some leftSpec, some rightSpec, some rootSpec =>
+        leftSpec.kind == .ixvm && rightSpec.kind == .ixvm &&
+          rootSpec.kind == .aggr && rootSpec.outerClaim == flatOuter
+      | _, _, _ => false
+    | .error _ => false
+  let policiesShareRootClaim : Bool := match wrapSpecs, directSpecs with
+    | .ok wraps, .ok direct => wraps.back?.map (·.outerClaim) ==
+        direct.back?.map (·.outerClaim)
+    | _, _ => false
+
+  -- Verified cache/resume against the converged outer claim.
+  let cachedWrapper : Ixon.Proof := {
+    claim := left.claim
+    proof := leftProof.toBytes
+  }
+  let validCached := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    selfSystem left.claim leftOuter cachedWrapper
+  let wrongCachedStatement := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    selfSystem right.claim leftOuter cachedWrapper
+  let wrongCachedOuter := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    selfSystem left.claim rightOuter cachedWrapper
+  let badProofBytes := leftProof.toBytes.set! 0
+    (UInt8.ofNat ((leftProof.toBytes.data[0]!.toNat + 1) % 256))
+  let badCachedProof := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    selfSystem left.claim leftOuter { cachedWrapper with proof := badProofBytes }
+
+  let cacheRoot ← IO.FS.createTempDir
+  let cacheDir ← Ix.Cli.AggregateCmd.aggregateCacheDir (some cacheRoot)
+  let missingEntry ← Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir leftKey
+  let cachedAddress := Address.blake3 (Ixon.Proof.ser cachedWrapper)
+  Ix.Cli.AggregateCmd.writeAggregateCacheAddress cacheDir leftKey cachedAddress
+  let presentEntry ← Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir leftKey
+  let tempEntryExists ← (cacheDir / s!"{leftKey}.tmp").pathExists
+  IO.FS.writeFile (cacheDir / toString leftKey) "corrupt-cache-entry"
+  let corruptEntry ← Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir leftKey
+  Ix.Cli.AggregateCmd.writeAggregateCacheAddress cacheDir leftKey cachedAddress
+  let recoveredEntry ← Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir leftKey
+  let missingIndexIsMiss : Bool := match missingEntry with
+    | .miss => true
+    | _ => false
+  let cacheIndexRoundTrip : Bool := match presentEntry with
+    | .hit address => address == cachedAddress
+    | _ => false
+  let cacheTempGone := !tempEntryExists
+  let corruptIndexRejected : Bool := match corruptEntry with
+    | .invalid _ => true
+    | _ => false
+  let corruptIndexRecovers : Bool := match recoveredEntry with
+    | .hit address => address == cachedAddress
+    | _ => false
+  let cachedBytes := Ixon.Proof.ser cachedWrapper
+  let resumed? ← match wrapSpecs with
+    | .ok specs =>
+      match specs[0]? with
+      | some spec =>
+        Ix.Cli.AggregateCmd.loadCachedAggregateProofWith
+          (fun _ => pure cachedBytes) cacheDir 0 spec selfSystem
+      | none => pure none
+    | .error _ => pure none
+  let corruptStore? ← match wrapSpecs with
+    | .ok specs =>
+      match specs[0]? with
+      | some spec =>
+        Ix.Cli.AggregateCmd.loadCachedAggregateProofWith
+          (fun _ => pure (cachedBytes.push 0xff)) cacheDir 0 spec selfSystem
+      | none => pure none
+    | .error _ => pure none
+
+  -- Manifest parsing, validate-before-prune, and value-based verification.
+  let manifestPlan :=
+    (Ix.Cli.CheckCmd.AggregationTree.node
+      (.node (.leaf 0) (.leaf 1)) (.leaf 2)).foldPlan
+  let expectedPlan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp :=
+    #[.leaf 0, .leaf 1, .join 0 1, .leaf 2, .join 2 3]
+  let parsedManifestPlan : Bool :=
+    let valid := minimalIxes (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 1)
+    match Ix.Cli.CheckCmd.parseIxesManifest valid with
+    | .ok view => view.aggregationTree.foldPlan ==
+        (#[.leaf 0, .leaf 1, .join 0 1] :
+          Array Ix.Cli.CheckCmd.AggregationTree.FoldOp)
+    | .error _ => false
+  let malformedManifestRejected : Bool :=
+    let duplicate := minimalIxes (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 0)
+    match Ix.Cli.CheckCmd.parseIxesManifest duplicate with
+    | .error _ => true
+    | .ok _ => false
+  let (singleEnv, singleAddr) := singletonIxonEnv
+  let singleTreeTail := #[1, 1, 0] ++ u32le4 0 ++ #[1, 0] ++
+    u32le4 1 ++ #[0] ++ u32le4 2
+  let singleManifest := Ix.Cli.CheckCmd.parseIxesManifest
+    (minimalIxesFor #[#[], #[singleAddr], #[]] singleTreeTail)
+  let singleCoverage ← match singleManifest with
+    | .ok view => Ix.Cli.CheckCmd.shardsCover singleEnv view.shards
+    | .error _ => pure false
+  let emptyPruningCorrect : Bool := match singleManifest with
+    | .ok view => match view.pruneEmpty singleEnv with
+      | .ok (pruned, counts) =>
+        pruned.shards == #[#[singleAddr]] && pruned.shardIds == #[1] &&
+          pruned.aggregationTree == .leaf 0 && counts == #[1]
+      | .error _ => false
+    | .error _ => false
+  let singletonValueRoot : Bool := match singleManifest with
+    | .ok view => match Ix.Cli.VerifyCmd.expectedFromManifest singleEnv view 0 with
+      | .ok statement =>
+        statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none
+      | .error _ => false
+    | .error _ => false
+  let nativePlanOnlyFfiWorks ← do
+    let dir ← IO.FS.createTempDir
+    let ixePath := dir / "native-plan.ixe"
+    let ixesPath := dir / "native-plan.ixes"
+    match Ixon.serEnv singleEnv with
+    | .error _ => pure false
+    | .ok envBytes =>
+      IO.FS.writeBinFile ixePath envBytes
+      IO.FS.writeBinFile ixesPath <| minimalIxesFor #[#[singleAddr]]
+        (#[1, 0] ++ u32le4 0 ++ #[0])
+      match Aiur.EnvHandle.fromIxe ixePath.toString with
+      | .error _ => pure false
+      | .ok handle =>
+        pure <| (ixvmSystem.aggregateStage2 selfSystem handle
+          ixesPath.toString "" verifyIdx fakeAggrIdx 1
+          (16 * 1024 * 1024 * 1024) 4096 false true
+          childRecursionParameters.cacheFriBytes false).isOk
+
+  let (pairEnv, pairLeft, pairRight) := pairIxonEnv
+  let pairManifest := Ix.Cli.CheckCmd.parseIxesManifest
+    (minimalIxesFor #[#[pairLeft], #[pairRight]]
+      (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 1))
+  let pairCoverage ← match pairManifest with
+    | .ok view => Ix.Cli.CheckCmd.shardsCover pairEnv view.shards
+    | .error _ => pure false
+  let batchedShardPreparationCorrect : Bool := match pairManifest with
+    | .ok view =>
+      match Ix.Cli.AggregateCmd.prepareShards pairEnv view.shards view.shardIds with
+      | .ok prepared =>
+        prepared.map (·.claim) == (#[(.checkEnv
+            (canonicalTree #[pairLeft]).root none : Ix.Claim),
+          .checkEnv (canonicalTree #[pairRight]).root none] : Array Ix.Claim) &&
+          prepared.all fun item => item.statement.claim == item.claim
+      | .error _ => false
+    | .error _ => false
+  let flatManifestValue : Option Aggr.CheckEnvTrees := match pairManifest with
+    | .ok view => (Ix.Cli.VerifyCmd.expectedFromManifest pairEnv view 8).toOption
+    | .error _ => none
+  let structuralManifestValue : Option Aggr.CheckEnvTrees := match pairManifest with
+    | .ok view => (Ix.Cli.VerifyCmd.expectedFromManifest pairEnv view 0).toOption
+    | .error _ => none
+  let canonicalEnvTree := canonicalTree #[pairLeft, pairRight]
+  let manifestFlatIsCanonical := flatManifestValue.map (·.claim) ==
+    some (.checkEnv canonicalEnvTree.root none)
+  let manifestStructuralIsHybrid := structuralManifestValue.map (·.claim) ==
+    some (.checkEnv
+      (Ix.Merkle.nodeHash (canonicalTree #[pairLeft]).root
+        (canonicalTree #[pairRight]).root) none)
+  let manifestValuesDiffer := flatManifestValue.map (·.claim) !=
+    structuralManifestValue.map (·.claim)
+
+  let shardPrepPreservesSemantics : Bool :=
+    let (sharedEnv, owned, sharedAddress) := sharedClosureIxonEnv
+    let legacyClosure : Std.HashSet Address := Id.run do
+      let mut closure : Std.HashSet Address := {}
+      for address in owned do
+        closure := closure.union (IxVM.ClaimHarness.closureFrom sharedEnv address)
+      pure closure
+    let expectedOwned := canonicalTree owned
+    let expectedFrontier := canonicalTree #[sharedAddress]
+    match IxVM.ClaimHarness.shardCheckEnvClaimTrees sharedEnv owned,
+        IxVM.ClaimHarness.shardCheckEnvClaim sharedEnv owned with
+    | .ok (claimOnly, treesOnly), .ok (claimFull, closure, treesFull) =>
+      let sameClosure := closure.size == legacyClosure.size &&
+        closure.toArray.all legacyClosure.contains
+      claimOnly == .checkEnv expectedOwned.root (some expectedFrontier.root) &&
+        claimFull == claimOnly && sameClosure &&
+        treesOnly.size == 2 && treesFull.size == 2 &&
+        treesOnly.contains expectedOwned.root &&
+        treesOnly.contains expectedFrontier.root &&
+        treesFull.contains expectedOwned.root &&
+        treesFull.contains expectedFrontier.root
+    | _, _ => false
+
+  -- Threshold policy and the RAM-gated DAG controller.
+  let mixedSchedule := Ix.Cli.AggregateCmd.schedulePlan
+    manifestPlan #[2, 2, 1] 4
+  let mixedScheduleCorrect : Bool := match mixedSchedule with
+    | .ok scheduled => match scheduled[2]?, scheduled[4]? with
+      | some lower, some upper =>
+        scheduled.size == 5 && lower.shape? == some 5 &&
+          lower.subjectCount == 4 && !lower.structural &&
+          upper.shape? == some 9 && upper.subjectCount == 5 && upper.structural
+      | _, _ => false
+    | .error _ => false
+  let fakeWeights : Array Nat := #[8, 3, 4, 6, 5]
+  let schedulerTrace := mixedSchedule.bind fun scheduled =>
+    Ix.Cli.AggregateCmd.simulateAggregateSchedule scheduled fakeWeights 2 10
+  let schedulerHeaviestFirst : Bool := match schedulerTrace with
+    | .ok trace => trace.admissionOrder == #[0, 3, 1, 2, 4] &&
+        trace.admissionBatches == #[#[0], #[3, 1], #[2], #[4]]
+    | .error _ => false
+  let schedulerWithinLimits : Bool := match schedulerTrace with
+    | .ok trace => trace.maxReservedBytes <= 10 &&
+        trace.admissionBatches.all (fun batch => batch.size <= 2)
+    | .error _ => false
+  let schedulerDependenciesHold : Bool := match schedulerTrace with
+    | .ok trace =>
+      let position (slot : Nat) := trace.admissionOrder.findIdx? (· == slot)
+      match position 0, position 1, position 2, position 3, position 4 with
+      | some p0, some p1, some p2, some p3, some p4 =>
+        p0 < p2 && p1 < p2 && p2 < p4 && p3 < p4
+      | _, _, _, _, _ => false
+    | .error _ => false
+  let oversizedRunsAlone : Bool := match mixedSchedule.bind fun scheduled =>
+      Ix.Cli.AggregateCmd.simulateAggregateSchedule scheduled
+        #[11, 3, 4, 6, 5] 2 10 with
+    | .ok trace => trace.admissionBatches[0]? == some #[0] &&
+        trace.admissionBatches.all fun batch =>
+          batch.size == 1 || batch.all fun slot => fakeWeights[slot]! <= 10
+    | .error _ => false
+  let flatWeightAffine :=
+    Ix.Cli.AggregateCmd.aggregateSlotRamBytes
+      { op := .join 0 1, subjectCount := 7, structural := false } ==
+      Ix.Cli.AggregateCmd.aggregateStructuralJoinRamBytes +
+        7 * Ix.Cli.AggregateCmd.aggregateFlatJoinRamPerSubjectBytes
+  let memTotalParsing := Ix.Cli.AggregateCmd.aggregateMemTotalBytes
+    "MemTotal:       1024 kB\nMemFree: 512 kB\n" == some (1024 * 1024)
+  let invalidScheduleRejected : Bool := match
+      Ix.Cli.AggregateCmd.schedulePlan #[.join 0 1] #[] 4 with
+    | .error _ => true
+    | .ok _ => false
+
+  let fakeRun (scheduled : Array Ix.Cli.AggregateCmd.ScheduledFold)
+      (slotIdx : Nat) (slots : Array (Option ByteArray)) :
+      IO (Except String ByteArray) := do
+    let some item := scheduled[slotIdx]? | return .error "missing fake slot"
+    match item.op with
+    | .leaf shard => pure (.ok ⟨#[UInt8.ofNat shard, UInt8.ofNat slotIdx]⟩)
+    | .join leftIdx rightIdx =>
+      let some leftPayload := (slots[leftIdx]?).join
+        | return .error "missing fake left child"
+      let some rightPayload := (slots[rightIdx]?).join
+        | return .error "missing fake right child"
+      pure (.ok ((leftPayload ++ rightPayload).push (UInt8.ofNat slotIdx)))
+  let schedulerSerialParallelParity ← match mixedSchedule with
+    | .error _ => pure false
+    | .ok scheduled =>
+      let serial ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        1 10 (fakeRun scheduled)
+      let parallel ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        2 10 (fakeRun scheduled)
+      pure <| match serial, parallel with
+        | .ok serial, .ok parallel => serial == parallel
+        | _, _ => false
+  let dependentStarted ← IO.mkRef false
+  let failureRun (slotIdx : Nat) (_ : Array (Option Nat)) :
+      IO (Except String Nat) := do
+    if slotIdx == 0 then return .error "intentional leaf failure"
+    if slotIdx == 2 then dependentStarted.set true
+    pure (.ok slotIdx)
+  let schedulerStopsAfterFailure ← match mixedSchedule with
+    | .error _ => pure false
+    | .ok scheduled =>
+      let result ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        2 10 failureRun
+      let started ← dependentStarted.get
+      pure <| match result with
+        | .error e => e.startsWith "slot 0: intentional leaf failure" && !started
+        | .ok _ => false
+
+  -- Exercise concurrent proof generation through the same Aiur system. Zero
+  -- query PoW has a canonical witness, so wrapper-byte equality isolates DAG
+  -- determinism rather than rayon choosing different valid grind witnesses.
+  let scheduledSystem := AiurSystem.build childCompiled.bytecode recCommitParams
+    { innerFri with queryProofOfWorkBits := 0 }
+  let scheduledVk := scheduledSystem.vkBytes
+  let scheduledAllowed := Aggr.allowedBlob ixvmVk verifyIdx scheduledVk fakeAggrIdx
+  let scheduledOuter (claim : Ix.Claim) :=
+    Ix.Cli.AggregateCmd.aggregateOuterClaim scheduledAllowed fakeAggrIdx claim
+  let scheduledProofSlot (slotIdx : Nat)
+      (slots : Array (Option ByteArray)) : IO (Except String ByteArray) := do
+    let claim := if slotIdx == 0 then left.claim
+      else if slotIdx == 1 then right.claim else flatOutput.claim
+    if slotIdx == 2 then
+      for (childIdx, childClaim) in #[(0, left.claim), (1, right.claim)] do
+        let some proofBytes := (slots[childIdx]?).join
+          | return .error s!"scheduled pair missing child {childIdx}"
+        let proof ← match Aiur.Proof.ofBytesChecked proofBytes with
+          | .error e => return .error e
+          | .ok proof => pure proof
+        match scheduledSystem.verify (scheduledOuter childClaim) proof with
+        | .ok () => pure ()
+        | .error e => return .error e
+    let claimBytes := Ix.Claim.ser claim
+    let (outer, proof, _) ← match scheduledSystem.prove fakeAggrIdx
+        (Aggr.pubInput scheduledAllowed claimBytes) default with
+      | .error e => return .error e
+      | .ok result => pure result
+    if outer != scheduledOuter claim then
+      return .error s!"scheduled slot {slotIdx} outer claim mismatch"
+    pure (.ok proof.toBytes)
+  let scheduledWrapperBytes (proofs : Array ByteArray) : Array ByteArray :=
+    proofs.mapIdx fun slotIdx proof =>
+      let claim := if slotIdx == 0 then left.claim
+        else if slotIdx == 1 then right.claim else flatOutput.claim
+      Ixon.Proof.ser { claim, proof }
+  let concurrentProofWrappersStable ← match wrapPlan with
+    | .error _ => pure false
+    | .ok scheduled =>
+      let serial ← Ix.Cli.AggregateCmd.runAggregateDag scheduled #[8, 8, 4]
+        1 16 scheduledProofSlot
+      let parallel ← Ix.Cli.AggregateCmd.runAggregateDag scheduled #[8, 8, 4]
+        2 16 scheduledProofSlot
+      pure <| match serial, parallel with
+        | .ok serial, .ok parallel =>
+          scheduledWrapperBytes serial == scheduledWrapperBytes parallel
+        | _, _ => false
+
+  lspecIO (.ofList [("ix-aggr-semantics", [
+    test "default recursion parameters preserve direct construction"
+      defaultRecursionIdentityPreserved,
+    test "recursion FRI cache encoding is the pinned 40-byte layout"
+      defaultFriEncodingStable,
+    test "FRI and commitment overrides independently change recursion identity"
+      recursionParametersIndependent,
+    test "aggregate cache version is 2" (Ix.Cli.AggregateCmd.aggregateCacheVersion == 2),
+    test "aggregate cache key is stable for identical inputs" cacheKeyStable,
+    test "aggregate cache key binds the uniform outer claim" cacheKeyBindsOuter,
+    test "aggregate cache key binds recursion FRI parameters" cacheKeyBindsFri,
+    test "aggregate cache key binds the recursion verifying key" cacheKeyBindsVk,
+    test "aggregate cache key rejects version-1 entries" cacheKeyBindsVersion,
+    test "Rust and Lean aggregate cache identity share a fixed vector"
+      cacheKeyMatchesRustVector,
+    test "wrap-first specs precompute every uniform claim and cache key"
+      wrapSpecsComplete,
+    test "direct specs retain raw IxVM leaves and one aggregate root"
+      directSpecsUseRawLeaves,
+    test "wrap-first and direct policies derive the same flat root claim"
+      policiesShareRootClaim,
+    test "aggregate outer claims bind the exact CheckEnv value" outerClaimBindsValue,
+    expectOk "cache accepts an exactly bound valid aggregate wrapper" validCached,
+    expectErr "cache rejects a wrapper for a different CheckEnv"
+      wrongCachedStatement,
+    expectErr "cache rejects a proof under a different aggregate claim"
+      wrongCachedOuter,
+    expectErr "cache rejects corrupted aggregate proof bytes" badCachedProof,
+    test "missing cache index is a clean miss" missingIndexIsMiss,
+    test "cache index atomically round-trips a store address" cacheIndexRoundTrip,
+    test "cache atomic update leaves no temporary entry" cacheTempGone,
+    test "cache treats a corrupt index as an invalid hint" corruptIndexRejected,
+    test "cache atomically replaces a corrupt index" corruptIndexRecovers,
+    test "cache resumes a content-addressed verified aggregate wrapper" resumed?.isSome,
+    test "cache treats corrupt store content as a miss" corruptStore?.isNone,
+    test "flat host fold constructs canonical union/discharge trees" flatHostCorrect,
+    test "structural host fold constructs root-of-roots and survivors"
+      structuralHostCorrect,
+    test "driver CheckEnv conversion round-trips free-form roots"
+      hostConversionRoundTrip,
+    test "manifest tree lowers to post-order binary slots"
+      (manifestPlan == expectedPlan),
+    test "manifest parser exposes its validated bisection tree" parsedManifestPlan,
+    test "manifest parser rejects repeated aggregation leaves"
+      malformedManifestRejected,
+    test "coverage accepts legacy zero-constant manifest leaves" singleCoverage,
+    test "empty manifest leaves contract and retained ids remap densely"
+      emptyPruningCorrect,
+    test "one retained shard reconstructs one value-based root" singletonValueRoot,
+    test "native Stage 2 FFI plans a serialized environment end-to-end"
+      nativePlanOnlyFfiWorks,
+    test "two-shard manifest passes exact environment coverage" pairCoverage,
+    test "aggregate startup prepares every shard from one ownership pass"
+      batchedShardPreparationCorrect,
+    test "flat manifest value equals the canonical environment root"
+      manifestFlatIsCanonical,
+    test "structural manifest value equals the manifest-relative hybrid root"
+      manifestStructuralIsHybrid,
+    test "flat and structural schedules produce distinguishable values"
+      manifestValuesDiffer,
+    test "shard prep preserves trees and one-pass closure semantics"
+      shardPrepPreservesSemantics,
+    test "threshold scheduling is flat below and structural above monotonically"
+      mixedScheduleCorrect,
+    test "RAM-gated scheduler admits ready work heaviest-first"
+      schedulerHeaviestFirst,
+    test "RAM-gated scheduler respects job and byte budgets"
+      schedulerWithinLimits,
+    test "RAM-gated scheduler waits for both pair children"
+      schedulerDependenciesHold,
+    test "an individually oversized scheduler slot is admitted alone"
+      oversizedRunsAlone,
+    test "flat self-pair RAM reserve is affine in subject leaves"
+      flatWeightAffine,
+    test "aggregate scheduler parses MemTotal for its default budget"
+      memTotalParsing,
+    test "invalid non-post-order schedules are rejected" invalidScheduleRejected,
+    test "jobs=2 DAG execution is byte-identical to jobs=1"
+      schedulerSerialParallelParity,
+    test "a failed slot drains peers without starting dependent pairs"
+      schedulerStopsAfterFailure,
+    test "jobs=2 zero-PoW aggregate wrappers are byte-identical to jobs=1"
+      concurrentProofWrappersStable,
+    expectOk "stand-in aggregate proof verifies under its uniform outer claim"
+      (selfSystem.verify leftOuter leftProof),
+    expectOk "second stand-in aggregate proof verifies independently"
+      (selfSystem.verify rightOuter rightProof)
+  ])]) []
+
+def convergedSuite : IO UInt32 := do
+  let shapes ← smokeSuite
+  let semantics ← semanticSuite
+  return if shapes == 0 && semantics == 0 then 0 else 1
+
+end Tests.Aggr
+
+end
diff --git a/Tests/Ix/BenchMeasures.lean b/Tests/Ix/BenchMeasures.lean
index 7a83e6276..7b2fffdf0 100644
--- a/Tests/Ix/BenchMeasures.lean
+++ b/Tests/Ix/BenchMeasures.lean
@@ -25,6 +25,9 @@ def testStagePrefix : TestSeq :=
       (stagePrefixOf "ixvm-verify-time" == some "ixvm-")
   ++ test "fri-verifier- prefix identified"
       (stagePrefixOf "fri-verifier-fft-cost" == some "fri-verifier-")
+  ++ test "join- strips" (dropStagePrefix "join-proof-size" == "proof-size")
+  ++ test "join- prefix identified"
+      (stagePrefixOf "join-execute-time" == some "join-")
   ++ test "unqualified name passes through"
       (dropStagePrefix "execute-time" == "execute-time")
   ++ test "prefix without dash is not a qualifier"
@@ -34,6 +37,10 @@ def testStagePrefix : TestSeq :=
   ++ test "phase spans pass through"
       (dropStagePrefix "phase-stark-stage1-commit"
         == "phase-stark-stage1-commit")
+  ++ test "aiur join pair is registered for dashboard filtering"
+      ((backendSpecs.find? (·.name == "aiur")).any fun backend =>
+        (backend.benchmarkNames "prove").contains
+          "Nat.add_comm + String.append")
 
 def suite : List TestSeq := [testStagePrefix]
 
diff --git a/Tests/Ix/Ixes.lean b/Tests/Ix/Ixes.lean
new file mode 100644
index 000000000..433b000fe
--- /dev/null
+++ b/Tests/Ix/Ixes.lean
@@ -0,0 +1,86 @@
+module
+
+import Ix.Cli.CheckCmd
+
+/-!
+`.ixes` manifest parser: the optional trailing sections (bisection tree,
+measured peaks) and the strict end-of-input check, on synthetic manifests
+built byte by byte so no environment is needed.
+-/
+
+namespace Tests.Ix.Ixes
+
+open Ix.Cli.CheckCmd (AggregationTree parseIxesManifest)
+
+private def u32 (n : Nat) : ByteArray := n.toUInt32.toLEBytes
+private def u64 (n : Nat) : ByteArray := n.toUInt64.toLEBytes
+
+private def fakeAddr (tag : UInt8) : ByteArray :=
+  ByteArray.mk (Array.replicate 32 tag)
+
+/-- One shard record: `id ‖ heartbeats ‖ own_size ‖ cross_ingress ‖
+    assumption_root(absent) ‖ blocks(1) ‖ foreign_blocks(0)`. -/
+private def record (id : Nat) : ByteArray :=
+  u32 id ++ u64 (100 + id) ++ u64 (200 + id) ++ u64 0
+    ++ ByteArray.mk #[0] ++ u32 1 ++ fakeAddr (id.toUInt8 + 1) ++ u32 0
+
+/-- Records only: the layout every writer starts with. -/
+private def recordsOnly : ByteArray :=
+  "IXES".toUTF8 ++ ByteArray.mk #[0, 0, 0, 0] ++ ByteArray.mk (Array.replicate 16 0)
+    ++ u32 2 ++ record 0 ++ record 1
+
+/-- `node(leaf 1, leaf 0)`: deliberately not the balanced fallback. -/
+private def treeSection : ByteArray :=
+  ByteArray.mk #[1, 1, 0] ++ u32 1 ++ ByteArray.mk #[0] ++ u32 0
+
+private def expect (name : String) (cond : Bool) : IO Bool := do
+  if cond then IO.println s!"  ✓ {name}" else IO.eprintln s!"  ✗ {name}"
+  pure cond
+
+private def isErrorContaining (r : Except String α) (needle : String) : Bool :=
+  match r with
+  | .error e => (e.splitOn needle).length > 1
+  | .ok _ => false
+
+public def suite : IO UInt32 := do
+  IO.println "ixes-manifest"
+  let balanced := AggregationTree.node (.leaf 0) (.leaf 1)
+  let custom := AggregationTree.node (.leaf 1) (.leaf 0)
+  let mut ok := true
+  -- 1. Records only: balanced tree fallback, unmeasured peaks.
+  let r1 := parseIxesManifest recordsOnly
+  ok := (← expect "records-only parses" r1.toBool) && ok
+  if let .ok v := r1 then
+    ok := (← expect "records-only: two shards, one block each"
+      (v.shards.size == 2 && v.shards.all (·.size == 1))) && ok
+    ok := (← expect "records-only: balanced tree fallback" (v.aggregationTree == balanced)) && ok
+    ok := (← expect "records-only: peaks unmeasured" (v.measuredPeakBytes == #[0, 0])) && ok
+  -- 2. Explicit zero presence bytes for both sections (what `ix shard`
+  --    writes for a planner manifest with no tree).
+  let r2 := parseIxesManifest (recordsOnly ++ ByteArray.mk #[0, 0])
+  ok := (← expect "zero presence bytes parse" r2.toBool) && ok
+  if let .ok v := r2 then
+    ok := (← expect "zero presence: balanced tree, zero peaks"
+      (v.aggregationTree == balanced && v.measuredPeakBytes == #[0, 0])) && ok
+  -- 3. Tree, then peaks.
+  let withPeaks := recordsOnly ++ treeSection ++ ByteArray.mk #[1] ++ u64 4096 ++ u64 0
+  let r3 := parseIxesManifest withPeaks
+  ok := (← expect "tree + peaks parse" r3.toBool) && ok
+  if let .ok v := r3 then
+    ok := (← expect "tree section is honoured" (v.aggregationTree == custom)) && ok
+    ok := (← expect "peaks read in id order" (v.measuredPeakBytes == #[4096, 0])) && ok
+  -- 4. Tree, no peaks section at all (pre-peaks writer).
+  let r4 := parseIxesManifest (recordsOnly ++ treeSection)
+  ok := (← expect "tree without peaks section parses" r4.toBool) && ok
+  if let .ok v := r4 then
+    ok := (← expect "tree without peaks: zero peaks" (v.measuredPeakBytes == #[0, 0])) && ok
+  -- 5. Strictness: anything after the last known section is an error.
+  ok := (← expect "trailing byte after peaks is rejected"
+    (isErrorContaining (parseIxesManifest (withPeaks ++ ByteArray.mk #[7])) "trailing")) && ok
+  ok := (← expect "bad peaks presence tag is rejected"
+    (isErrorContaining (parseIxesManifest (recordsOnly ++ treeSection ++ ByteArray.mk #[2])) "presence tag")) && ok
+  ok := (← expect "truncated peaks section is rejected"
+    (isErrorContaining (parseIxesManifest (recordsOnly ++ treeSection ++ ByteArray.mk #[1] ++ u64 1)) "truncated")) && ok
+  pure (if ok then 0 else 1)
+
+end Tests.Ix.Ixes
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 6e9b547ce..331b32a66 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -53,7 +53,11 @@ import Tests.Ix.CondenseM
 import Tests.FFI
 import Tests.Keccak
 import Tests.MultiStark
+import Tests.Aggr
+import Tests.AggrSemantics
+import Tests.AggrActivation
 import Tests.Cli
+import Tests.Ix.Ixes
 import Tests.ShardMap
 import Tests.Ix.EnvBody
 import Tests.Ix.Lean4Lean
@@ -184,6 +188,12 @@ def primaryRunners : List (String × IO UInt32) := [
   -- factorial-prove → recursive-verify → reject-tampering pipeline.
   ("multi-stark", Tests.MultiStark.selfTestSuite),
   ("recursive-verifier", Tests.MultiStark.endToEndSuite),
+  ("aggregate-first", Tests.MultiStark.joinSmokeSuite),
+  -- Converged heterogeneous aggregation circuit: all ten `ix_aggr` shapes,
+  -- driver/cache semantics, and one negative case per broken binding.
+  ("ix-aggr", Tests.Aggr.convergedSuite),
+  -- `.ixes` manifest parser: trailing tree/peaks sections and strictness.
+  ("ixes-manifest", Tests.Ix.Ixes.suite),
 ]
 
 /-- Ignored test runners - expensive, deferred IO actions run only when explicitly requested -/
@@ -317,6 +327,12 @@ def main (args : List String) : IO UInt32 := do
   if args.contains "cli" then
     return ← Tests.Cli.suite
 
+  -- Section 14 M1-e diagnostic: keep the 132-case, twice-executed `ix_aggr`
+  -- activation matrix out of the default primary suite while making its gate
+  -- explicit and independent of the large environment used by ignored tests.
+  if args.contains "aggregate-activation" then
+    return ← Tests.Aggr.activationAudit
+
   let runIgnored := args.contains "--ignored"
   let includeIgnored := args.contains "--include-ignored"
   -- `--exclude=a,b,c` drops named ignored suites and runners from an unfiltered sweep.
diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean
index 26d62327d..c44848949 100644
--- a/Tests/MultiStark.lean
+++ b/Tests/MultiStark.lean
@@ -5,6 +5,12 @@ public import Ix.Aiur.Meta
 public import Ix.Aiur.Protocol
 public import Ix.Aiur.Compiler
 public import Ix.MultiStark
+public import Ix.Cli.AggregateCmd
+public import Ix.Cli.CheckCmd
+public import Ix.Cli.VerifyCmd
+public import Ix.Claim
+public import Ix.AssumptionTree
+public import Ix.Merkle
 public import Blake3.Rust
 
 /-!
@@ -157,7 +163,11 @@ def endToEndSuite : IO UInt32 := do
     | .ok result => pure result
     | .error e => IO.eprintln s!"factorial prove failed: {e}"; return 1
   let expectedClaim := buildClaim facIdx input #[Aiur.G.ofNat 120]
-  let proofBytes := proof.toBytes
+  -- The in-circuit verifier consumes the per-query advice transport, not
+  -- the pruned-multiproof wire format `Proof.toBytes` carries.
+  let proofBytes ← match facSystem.proofToAdviceBytes claim proof with
+    | .ok bytes => pure bytes
+    | .error e => IO.eprintln s!"advice re-encoding failed: {e}"; return 1
 
   -- ── serialize proof (advice) + vk + claims, with public Blake3 digests ──
   let proofGs : Array Aiur.G := proofBytes.data.map .ofUInt8
@@ -187,10 +197,16 @@ def endToEndSuite : IO UInt32 := do
     | none => IO.eprintln "verify_multi_stark_proof entrypoint not found"; return 1
 
   -- ── negative-test inputs ────────────────────────────────────────────────────
-  -- Tampered proof advice: flip byte 0 (the first stage_1-commitment limb) so the
-  -- replayed Fiat-Shamir transcript diverges from the one the proof was made under.
+  -- Tampered proof advice: locate the first stage-1 commitment byte after the
+  -- native proof's `Vec<bool>` activation bitmap and cap-length prefix. This
+  -- keeps the proof structurally parseable while forcing Fiat-Shamir and the
+  -- Merkle checks away from the proof that was actually produced.
+  let activeLen := (List.range 8).foldl (fun n i =>
+    n ||| (proofBytes.data[i]!.toUInt64 <<< (i * 8).toUInt64)) 0
+  let firstCommitByte := 8 + activeLen.toNat + 8
   let badProofBytes :=
-    proofBytes.set! 0 (UInt8.ofNat ((proofBytes.data[0]!.toNat + 1) % 256))
+    proofBytes.set! firstCommitByte
+      (UInt8.ofNat ((proofBytes.data[firstCommitByte]!.toNat + 1) % 256))
   -- Tampered claim (with a matching keccak digest): 120 → 121. Feeds a different
   -- value into Fiat-Shamir (→ different ζ) and the lookup accumulator, so the
   -- composition/quotient identity no longer holds even though the binding passes.
@@ -201,7 +217,9 @@ def endToEndSuite : IO UInt32 := do
 
   -- ── run the (expensive) checks, then assert ─────────────────────────────────
   IO.println "recursive-verifier (proving + recursive verification, ~1.5 min)…"
-  let innerVerify := facSystem.verify claim (.ofBytes proofBytes)
+  -- Native wire-format roundtrip; the in-circuit paths below consume the
+  -- per-query advice encoding instead.
+  let innerVerify := facSystem.verify claim (.ofBytes proof.toBytes)
   -- Native path: Rust-built advice buffer + codegen'd verifier
   -- (`crates/ixvm-codegen/src/aiur_multi_stark.rs`).
   let honest :=
@@ -228,6 +246,912 @@ def endToEndSuite : IO UInt32 := do
     expectErr "tampered claim rejected (OOD/accumulator mismatch)" tamperedClaim,
   ])]) []
 
+-- ════════════════════════════════════════════════════════════════════════════
+-- `aggregate-first`: execute a real two-child canonical set-discharge join
+-- ═════════════════════════════════════════════════════════════════════════════
+
+/-- A tiny stand-in recursion system used to exercise both join modes without first
+proving the full recursive verifier (the production lift needs tens of GiB).
+The join still verifies two real Multi-STARK proofs and enforces their vk,
+entrypoint, public-input, and nested-claim bindings. -/
+def joinChildProgram : Source.Toplevel := ⟦
+  fn activation_height_probe(n: G) {
+    match n {
+      0 => (),
+      _ => activation_height_probe(n - 1),
+    }
+  }
+
+  fn activation_vary_height(digest: [G; 8]) {
+    match u32_less_than(digest[0], digest[1]) {
+      1 => activation_height_probe(1),
+      _ => activation_height_probe(4),
+    }
+  }
+
+  pub fn fake_verify_claim(digest: [G; 8]) {
+    activation_vary_height(digest)
+  }
+  pub fn fake_lift(system_digest: [G; 8], _claims_digest: [G; 8]) {
+    activation_vary_height(system_digest)
+  }
+  pub fn fake_join(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) {
+    activation_vary_height(allowed_digest);
+    assert_eq!(load(store(allowed_digest[0])), allowed_digest[0]);
+    ()
+  }
+  pub fn fake_struct_join(allowed_digest: [G; 8], _out_claim_digest: [G; 8]) {
+    activation_vary_height(allowed_digest);
+    assert_eq!(load(store(allowed_digest[1])), allowed_digest[1]);
+    assert_eq!(load(store(allowed_digest[2])), allowed_digest[2]);
+    ()
+  }
+⟧
+
+private def bytesAsGs (bytes : ByteArray) : Array Aiur.G :=
+  bytes.data.map .ofUInt8
+
+private def u32le4 (n : Nat) : Array UInt8 :=
+  (Array.range 4).map fun i => UInt8.ofNat ((n >>> (8 * i)) % 256)
+
+private def minimalIxesFor (shards : Array (Array Address))
+    (treeTail : Array UInt8) : ByteArray :=
+  let putAddresses := fun (addresses : Array Address) =>
+    addresses.foldl (fun out address => out ++ address.hash.data)
+      (u32le4 addresses.size)
+  let shard := fun id blocks => u32le4 id ++ Array.replicate 24 0 ++ #[0] ++
+    putAddresses blocks ++ u32le4 0
+  let body := (shards.mapIdx shard).foldl (· ++ ·) #[]
+  ⟨#[0x49, 0x58, 0x45, 0x53, 0, 0, 0, 0] ++ Array.replicate 16 0 ++
+    u32le4 shards.size ++ body ++ treeTail⟩
+
+private def minimalIxes (treeTail : Array UInt8) : ByteArray :=
+  minimalIxesFor #[#[], #[]] treeTail
+
+private def singletonIxonEnv : Ixon.Env × Address :=
+  let constant : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let address := Address.blake3 (Ixon.serConstant constant)
+  (({} : Ixon.Env).storeConst address constant, address)
+
+/-- Two owned constants with one shared dependency. This is the shape that made
+the old shard preparation path repeatedly traverse the same large core. -/
+private def sharedClosureIxonEnv : Ixon.Env × Array Address × Address :=
+  let shared : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩
+  let sharedAddress := Address.blake3 (Ixon.serConstant shared)
+  let left : Ixon.Constant :=
+    ⟨.axio ⟨false, 0, .ref 0 #[]⟩, #[], #[sharedAddress], #[]⟩
+  let right : Ixon.Constant :=
+    ⟨.axio ⟨true, 0, .ref 0 #[]⟩, #[], #[sharedAddress], #[]⟩
+  let leftAddress := Address.blake3 (Ixon.serConstant left)
+  let rightAddress := Address.blake3 (Ixon.serConstant right)
+  let env := (({} : Ixon.Env).storeConst sharedAddress shared)
+    |>.storeConst leftAddress left
+    |>.storeConst rightAddress right
+  (env, #[leftAddress, rightAddress], sharedAddress)
+
+private def canonicalTree (leaves : Array Address) : Ix.AssumptionTree :=
+  (Ix.AssumptionTree.canonical leaves).get!
+
+private def seedJoinTree (io : IOBuffer) (tree : Ix.AssumptionTree) : IOBuffer :=
+  io.extend 5 (bytesAsGs tree.root.hash)
+    (bytesAsGs (Ix.AssumptionTree.ser tree))
+
+private def seedJoinTrees (io : IOBuffer)
+    (trees : Array Ix.AssumptionTree) : IOBuffer :=
+  trees.foldl seedJoinTree io
+
+def joinSmokeSuite : IO UInt32 := do
+  let childCompiled ← match joinChildProgram.compile with
+    | .error e => IO.eprintln s!"join child compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let childSystem := AiurSystem.build childCompiled.bytecode recCommitParams innerFri
+
+  -- Pin the new recursion-parameter seam before exercising the join protocol.
+  -- The default helper must reproduce the former direct construction exactly;
+  -- the stable FRI bytes are the future cache-key component from the plan.
+  let recursionDefaults := MultiStark.defaultRecursionParameters
+  let defaultRecursionSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode recursionDefaults
+  let legacyDefaultRecursionSystem := AiurSystem.build childCompiled.bytecode
+    Aiur.defaultCommitmentParameters Aiur.defaultFriParameters
+  let expectedDefaultFriBytes : ByteArray :=
+    ⟨u64le 0 ++ u64le 1 ++ u64le 100 ++ u64le 0 ++ u64le 20⟩
+  let tunedFri : Aiur.FriParameters :=
+    { recursionDefaults.fri with numQueries := 50 }
+  let tunedFriParameters : MultiStark.RecursionParameters :=
+    { recursionDefaults with fri := tunedFri }
+  let tunedFriSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode tunedFriParameters
+  let tunedCommitment : Aiur.CommitmentParameters :=
+    { recursionDefaults.commitment with logBlowup := 3 }
+  let tunedCommitmentParameters : MultiStark.RecursionParameters :=
+    { recursionDefaults with commitment := tunedCommitment }
+  let tunedCommitmentSystem :=
+    MultiStark.buildRecursionSystem childCompiled.bytecode tunedCommitmentParameters
+  let defaultRecursionIdentityPreserved :=
+    defaultRecursionSystem.vkBytes == legacyDefaultRecursionSystem.vkBytes
+  let defaultFriEncodingStable :=
+    recursionDefaults.cacheFriBytes.size == 40 &&
+      recursionDefaults.cacheFriBytes == expectedDefaultFriBytes
+  let recursionParametersIndependent :=
+    tunedFriParameters.cacheFriBytes != recursionDefaults.cacheFriBytes &&
+      tunedFriSystem.vkBytes != defaultRecursionSystem.vkBytes &&
+      tunedCommitmentParameters.cacheFriBytes == recursionDefaults.cacheFriBytes &&
+      tunedCommitmentSystem.vkBytes != defaultRecursionSystem.vkBytes
+
+  let verifyIdx := childCompiled.getFuncIdx `fake_verify_claim |>.get!
+  let liftIdx := childCompiled.getFuncIdx `fake_lift |>.get!
+  let childJoinIdx := childCompiled.getFuncIdx `fake_join |>.get!
+  let childStructuralJoinIdx := childCompiled.getFuncIdx `fake_struct_join |>.get!
+
+  -- Two conditional shard statements whose assumptions cross the subject
+  -- boundary.  The join must compute
+  --   subjects    = {a,b} ∪ {c}       = {a,b,c}
+  --   assumptions = ({c,d} ∪ {a}) ∖ {a,b,c} = {d}.
+  let a := Address.blake3 "aggregate-a".toUTF8
+  let b := Address.blake3 "aggregate-b".toUTF8
+  let c := Address.blake3 "aggregate-c".toUTF8
+  let d := Address.blake3 "aggregate-d".toUTF8
+  let e := Address.blake3 "aggregate-extra".toUTF8
+  let leftSubjects := canonicalTree #[a, b]
+  let leftAssumptions := canonicalTree #[c, d]
+  let rightSubjects := canonicalTree #[c]
+  let rightAssumptions := canonicalTree #[a]
+  let leftStatement : MultiStark.CheckEnvTrees :=
+    { subjects := leftSubjects, assumptions := some leftAssumptions }
+  let rightStatement : MultiStark.CheckEnvTrees :=
+    { subjects := rightSubjects, assumptions := some rightAssumptions }
+  let outputStatement := leftStatement.join rightStatement
+  let outputSubjects := outputStatement.subjects
+  let outputAssumptions := outputStatement.assumptions.get!
+  let adviceTrees := MultiStark.CheckEnvTrees.adviceTrees
+    leftStatement rightStatement outputStatement
+  let leftClaimBytes := Ix.Claim.ser leftStatement.claim
+  let rightClaimBytes := Ix.Claim.ser rightStatement.claim
+
+  -- A lift's outer claim commits to serialized IxVM claims. Build those
+  -- nested preimages exactly as production does, then prove two cheap stand-in
+  -- lift executions under one vk.
+  let mkLift (claimBytes : ByteArray) :=
+    let innerInput := MultiStark.digestGs claimBytes
+    let innerClaim := Aiur.buildClaim verifyIdx innerInput #[]
+    let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim]
+    let fakeIxvmVk : ByteArray := ⟨#[0x49, 0x58, 0x56, 0x4d]⟩
+    let liftInput := MultiStark.verifierPubInput fakeIxvmVk innerClaimsBytes
+    (childSystem.prove liftIdx liftInput default).map fun (outerClaim, proof, _) =>
+      (fakeIxvmVk, innerClaimsBytes, outerClaim, proof)
+  let (fakeIxvmVk, leftInnerClaims, leftOuter, leftProof) ←
+    match mkLift leftClaimBytes with
+    | .error e => IO.eprintln s!"left lift prove failed: {e}"; return 1
+    | .ok result => pure result
+  let (_, rightInnerClaims, rightOuter, rightProof) ←
+    match mkLift rightClaimBytes with
+    | .error e => IO.eprintln s!"right lift prove failed: {e}"; return 1
+    | .ok result => pure result
+  let leftProofAdvice ← match childSystem.proofToAdviceBytes leftOuter leftProof with
+    | .error e => IO.eprintln s!"left proof advice encoding failed: {e}"; return 1
+    | .ok bytes => pure bytes
+  let rightProofAdvice ← match childSystem.proofToAdviceBytes rightOuter rightProof with
+    | .error e => IO.eprintln s!"right proof advice encoding failed: {e}"; return 1
+    | .ok bytes => pure bytes
+
+  let recursionVk := childSystem.vkBytes
+  let allowed := MultiStark.allowedBlob fakeIxvmVk verifyIdx recursionVk
+    liftIdx childJoinIdx childStructuralJoinIdx
+  let childRecursionParameters : MultiStark.RecursionParameters := {
+    commitment := recCommitParams
+    fri := innerFri
+  }
+  let liftCacheKey := Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+    childRecursionParameters leftOuter
+  let cacheKeyInputsBound :=
+    liftCacheKey == Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+      childRecursionParameters leftOuter &&
+    liftCacheKey != Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+      childRecursionParameters rightOuter &&
+    liftCacheKey != Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+      { childRecursionParameters with fri := tunedFri } leftOuter &&
+    liftCacheKey != Ix.Cli.AggregateCmd.aggregateCacheKey
+      (recursionVk.set! 0 (recursionVk.data[0]! + 1))
+        childRecursionParameters leftOuter &&
+    liftCacheKey != Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+      childRecursionParameters leftOuter
+        (Ix.Cli.AggregateCmd.aggregateCacheVersion + 1)
+  let cachedLiftWrapper : Ixon.Proof := {
+    claim := leftStatement.claim
+    proof := leftProof.toBytes
+  }
+  let validCachedLift := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    childSystem leftStatement.claim leftOuter cachedLiftWrapper
+  let wrongCachedStatement := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    childSystem rightStatement.claim leftOuter cachedLiftWrapper
+  let wrongCachedOuterClaim := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    childSystem leftStatement.claim rightOuter cachedLiftWrapper
+  let badCachedProofBytes := leftProof.toBytes.set! 0
+    (UInt8.ofNat ((leftProof.toBytes.data[0]!.toNat + 1) % 256))
+  let badCachedProof := Ix.Cli.AggregateCmd.validateAggregateCacheWrapper
+    childSystem leftStatement.claim leftOuter
+      { cachedLiftWrapper with proof := badCachedProofBytes }
+
+  -- Exercise the wipeable index hermetically. Its content is only an address;
+  -- wrapper binding and cryptographic validity are checked above.
+  let cacheRoot ← IO.FS.createTempDir
+  let cacheDir ← Ix.Cli.AggregateCmd.aggregateCacheDir (some cacheRoot)
+  let missingCacheEntry ←
+    Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir liftCacheKey
+  let cachedLiftAddress := Address.blake3 (Ixon.Proof.ser cachedLiftWrapper)
+  Ix.Cli.AggregateCmd.writeAggregateCacheAddress cacheDir liftCacheKey
+    cachedLiftAddress
+  let presentCacheEntry ←
+    Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir liftCacheKey
+  let tempEntryExists ← (cacheDir / s!"{liftCacheKey}.tmp").pathExists
+  let tempEntryGone := !tempEntryExists
+  IO.FS.writeFile (cacheDir / toString liftCacheKey) "corrupt-cache-entry"
+  let corruptCacheEntry ←
+    Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir liftCacheKey
+  Ix.Cli.AggregateCmd.writeAggregateCacheAddress cacheDir liftCacheKey
+    cachedLiftAddress
+  let recoveredCacheEntry ←
+    Ix.Cli.AggregateCmd.readAggregateCacheAddress cacheDir liftCacheKey
+  let cacheIndexRoundTrip : Bool := match missingCacheEntry, presentCacheEntry with
+    | .miss, .hit address => address == cachedLiftAddress && tempEntryGone
+    | _, _ => false
+  let corruptCacheIndexRejected : Bool := match corruptCacheEntry with
+    | .invalid _ => true
+    | _ => false
+  let corruptCacheIndexRecovers : Bool := match recoveredCacheEntry with
+    | .hit address => address == cachedLiftAddress
+    | _ => false
+
+  let reconstructedLiftClaim :=
+    let claimBytes := Ix.Claim.ser leftStatement.claim
+    let innerClaim := Aiur.buildClaim verifyIdx
+      (IxVM.ClaimHarness.packedDigestKey (Address.blake3 claimBytes)) #[]
+    let innerClaimsBytes := MultiStark.serializeClaims #[innerClaim]
+    Aiur.buildClaim liftIdx
+      (MultiStark.verifierPubInput fakeIxvmVk innerClaimsBytes) #[]
+  let liftClaimReconstruction := reconstructedLiftClaim == leftOuter
+  let reconstructedLiftVerifies :=
+    childSystem.verify reconstructedLiftClaim leftProof
+  let outputClaimBytes := Ix.Claim.ser outputStatement.claim
+  let pubInput := MultiStark.joinPubInput allowed outputClaimBytes
+  let cachePlan : Array Ix.Cli.AggregateCmd.ScheduledFold := #[
+    { op := .leaf 0, subjectCount := 2, structural := false },
+    { op := .leaf 1, subjectCount := 1, structural := false },
+    { op := .join 0 1, subjectCount := 3, structural := false }
+  ]
+  -- Keep the legacy backend's cache regression self-contained now that the
+  -- pre-convergence production slot-derivation shim has been retired.
+  let rootOuter := Aiur.buildClaim childJoinIdx pubInput #[]
+  let cacheSpecs : Array Ix.Cli.AggregateCmd.AggregateSlotSpec := #[
+    { statement := leftStatement, subjectCount := 2, outerClaim := leftOuter,
+      cacheKey := liftCacheKey },
+    { statement := rightStatement, subjectCount := 1, outerClaim := rightOuter,
+      cacheKey := Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+        childRecursionParameters rightOuter },
+    { statement := outputStatement, subjectCount := 3, outerClaim := rootOuter,
+      cacheKey := Ix.Cli.AggregateCmd.aggregateCacheKey recursionVk
+        childRecursionParameters rootOuter }
+  ]
+  let cachedLiftBytes := Ixon.Proof.ser cachedLiftWrapper
+  let resumedLift? ← match cacheSpecs[0]? with
+    | some spec =>
+      Ix.Cli.AggregateCmd.loadCachedAggregateProofWith
+        (fun _ => pure cachedLiftBytes) cacheDir 0 spec childSystem
+    | none => pure none
+  let corruptStoreLift? ← match cacheSpecs[0]? with
+    | some spec =>
+      Ix.Cli.AggregateCmd.loadCachedAggregateProofWith
+        (fun _ => pure (cachedLiftBytes.push 0xff))
+        cacheDir 0 spec childSystem
+    | none => pure none
+  let verifiedResumeHit := resumedLift?.isSome
+  let corruptStoreFallsThrough := corruptStoreLift?.isNone
+
+  let leftOuterBytes := MultiStark.serializeClaims #[leftOuter]
+  let rightOuterBytes := MultiStark.serializeClaims #[rightOuter]
+  let leftInnerDigest := MultiStark.digestGs leftInnerClaims
+  let rightInnerDigest := MultiStark.digestGs rightInnerClaims
+  let leftClaimDigest := MultiStark.digestGs leftClaimBytes
+  let rightClaimDigest := MultiStark.digestGs rightClaimBytes
+  let preimagesBlob := MultiStark.joinPreimagesBlob
+    #[leftInnerClaims, rightInnerClaims, leftClaimBytes, rightClaimBytes]
+  let treesBlob := MultiStark.joinTreesBlob
+    adviceTrees
+  let emptyPathsBlob := MultiStark.joinPathsBlob #[]
+  let zeroKey := #[Aiur.G.ofNat 0]
+  let oneKey := #[Aiur.G.ofNat 1]
+  let twoKey := #[Aiur.G.ofNat 2]
+  let io := seedJoinTrees ((default : IOBuffer)
+    |>.extend 0 zeroKey (bytesAsGs leftProofAdvice)
+    |>.extend 0 oneKey (bytesAsGs rightProofAdvice)
+    |>.extend 1 zeroKey (bytesAsGs recursionVk)
+    |>.extend 2 zeroKey (bytesAsGs leftOuterBytes)
+    |>.extend 2 oneKey (bytesAsGs rightOuterBytes)
+    |>.extend 2 twoKey (bytesAsGs outputClaimBytes)
+    |>.extend 3 zeroKey (bytesAsGs allowed)
+    |>.extend 4 leftInnerDigest (bytesAsGs leftInnerClaims)
+    |>.extend 4 rightInnerDigest (bytesAsGs rightInnerClaims)
+    |>.extend 4 leftClaimDigest (bytesAsGs leftClaimBytes)
+    |>.extend 4 rightClaimDigest (bytesAsGs rightClaimBytes))
+    adviceTrees
+
+  let top ← match MultiStark.multiStark with
+    | .error e => IO.eprintln s!"aggregate toplevel merge failed: {e}"; return 1
+    | .ok t => pure t
+  let compiled ← match top.compile with
+    | .error e => IO.eprintln s!"aggregate compilation failed: {e}"; return 1
+    | .ok c => pure c
+  let joinIdx := compiled.getFuncIdx `join_two |>.get!
+  let structuralJoinIdx := compiled.getFuncIdx `join_two_structural |>.get!
+  let honestInterp := compiled.bytecode.execute joinIdx pubInput io
+  let honest := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput
+    leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes
+    outputClaimBytes allowed preimagesBlob treesBlob emptyPathsBlob
+  let nativeParity : Bool := match honest, honestInterp with
+    | .ok (out, qc), .ok (outI, _, qcI) =>
+      out == outI && qc.size == qcI.size &&
+        (qc.zip qcI).all fun (x, y) =>
+          x.uniqueRows == y.uniqueRows && x.totalHits == y.totalHits
+    | _, _ => false
+
+  let malformedFraming := compiled.bytecode.executeMultiStarkJoin joinIdx pubInput
+    leftProofAdvice rightProofAdvice recursionVk leftOuterBytes rightOuterBytes
+    outputClaimBytes allowed ⟨#[]⟩ treesBlob emptyPathsBlob
+
+  -- Structural mode commits to `nodeHash(leftRoot, rightRoot)` and replaces
+  -- the full subject-list merge with one path choice per assumption candidate.
+  let structuralOutput := leftStatement.joinStructural rightStatement
+  let structuralClaimBytes := Ix.Claim.ser structuralOutput.claim
+  let structuralInput := MultiStark.joinPubInput allowed structuralClaimBytes
+  let structuralTreesBlob := MultiStark.joinTreesBlob
+    (MultiStark.CheckEnvTrees.structuralAdviceTrees
+      leftStatement rightStatement structuralOutput)
+  let structuralPathAdvice := MultiStark.CheckEnvTrees.structuralPathAdvice
+    leftStatement rightStatement structuralOutput
+  let structuralPathsBlob := MultiStark.joinPathsBlob structuralPathAdvice
+  let structuralHonest := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    structuralInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob
+    structuralTreesBlob structuralPathsBlob
+  let structuralInterp := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    structuralInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob
+    structuralTreesBlob structuralPathsBlob true
+  let structuralParity : Bool := match structuralHonest, structuralInterp with
+    | .ok (out, qc), .ok (outI, qcI) =>
+      out == outI && qc.size == qcI.size &&
+        (qc.zip qcI).all fun (x, y) =>
+          x.uniqueRows == y.uniqueRows && x.totalHits == y.totalHits
+    | _, _ => false
+  let structuralHostCorrect :=
+    structuralOutput.subjects.root ==
+      Ix.Merkle.nodeHash leftStatement.subjects.root rightStatement.subjects.root &&
+    structuralOutput.assumptions.map (·.leaves) == some (canonicalTree #[d]).leaves &&
+    structuralPathAdvice.size == 3
+
+  -- A path that stops at the left child root never reaches the structural
+  -- output root.
+  let wrongRootPathAdvice := structuralPathAdvice.map fun (candidate, path?) =>
+    if candidate == a then (candidate, leftSubjects.merkleProof candidate)
+    else (candidate, path?)
+  let wrongRootPath := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    structuralInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob
+    structuralTreesBlob (MultiStark.joinPathsBlob wrongRootPathAdvice)
+
+  -- Alter one sibling while retaining a syntactically valid path.
+  let tamperedPathAdvice := structuralPathAdvice.map fun (candidate, path?) =>
+    if candidate == a then
+      match path? with
+      | some path => match path[0]? with
+        | some (_, side) => (candidate, some (path.set! 0 (e, side)))
+        | none => (candidate, path?)
+      | none => (candidate, path?)
+    else (candidate, path?)
+  let tamperedPath := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    structuralInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob
+    structuralTreesBlob (MultiStark.joinPathsBlob tamperedPathAdvice)
+
+  -- Omitting a candidate's keyed choice makes its mandatory channel-6 lookup
+  -- fail; there is no implicit "not discharged" default.
+  let droppedPathAdvice := structuralPathAdvice.filter fun (candidate, _) =>
+    candidate != d
+  let droppedAssumption := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    structuralInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes allowed preimagesBlob
+    structuralTreesBlob (MultiStark.joinPathsBlob droppedPathAdvice)
+
+  -- Candidate d chooses "carried", but this output claim/list omits it.
+  let missingCarriedOutput : MultiStark.CheckEnvTrees :=
+    { subjects := structuralOutput.subjects, assumptions := none }
+  let missingCarriedBytes := Ix.Claim.ser missingCarriedOutput.claim
+  let missingCarriedInput := MultiStark.joinPubInput allowed missingCarriedBytes
+  let missingCarriedTrees := MultiStark.joinTreesBlob
+    (MultiStark.CheckEnvTrees.structuralAdviceTrees
+      leftStatement rightStatement missingCarriedOutput)
+  let missingCarriedPaths := MultiStark.joinPathsBlob
+    (MultiStark.CheckEnvTrees.structuralPathAdvice
+      leftStatement rightStatement missingCarriedOutput)
+  let missingCarried := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    missingCarriedInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes missingCarriedBytes allowed preimagesBlob
+    missingCarriedTrees missingCarriedPaths
+
+  -- The v1 identity blob is digest-consistent but lacks struct_join_idx.
+  let oldAllowed := allowed.extract 0 88
+  let oldAllowedInput := MultiStark.joinPubInput oldAllowed structuralClaimBytes
+  let oldAllowedRejected := compiled.bytecode.executeMultiStarkJoin structuralJoinIdx
+    oldAllowedInput leftProofAdvice rightProofAdvice recursionVk
+    leftOuterBytes rightOuterBytes structuralClaimBytes oldAllowed preimagesBlob
+    structuralTreesBlob structuralPathsBlob
+
+  -- Exercise the other child decoder arm: an aggregate child must expose the
+  -- same allowed digest transitively, while its output-claim preimage replaces
+  -- a lift's two nested preimages.
+  let joinChildInput := MultiStark.joinPubInput allowed leftClaimBytes
+  let (joinChildOuter, joinChildProof, _) ←
+    match childSystem.prove childJoinIdx joinChildInput default with
+    | .error e => IO.eprintln s!"join child prove failed: {e}"; return 1
+    | .ok result => pure result
+  let joinChildOuterBytes := MultiStark.serializeClaims #[joinChildOuter]
+  let joinChildLayout :=
+    joinChildOuter.extract 2 10 == MultiStark.digestGs allowed &&
+    joinChildOuter.extract 10 18 == MultiStark.digestGs leftClaimBytes
+  let joinChildNativeVerify := childSystem.verify joinChildOuter joinChildProof
+  let joinChildProofAdvice ← match childSystem.proofToAdviceBytes
+      joinChildOuter joinChildProof with
+    | .error e => IO.eprintln s!"join child advice encoding failed: {e}"; return 1
+    | .ok bytes => pure bytes
+  let joinChildIo := io
+    |>.extend 0 zeroKey (bytesAsGs joinChildProofAdvice)
+    |>.extend 2 zeroKey (bytesAsGs joinChildOuterBytes)
+  let transitiveJoin := compiled.bytecode.execute joinIdx pubInput joinChildIo
+
+  let wrongAllowed := allowed.set! 0
+    (UInt8.ofNat ((allowed.data[0]!.toNat + 1) % 256))
+  let wrongJoinChildInput := MultiStark.joinPubInput wrongAllowed leftClaimBytes
+  let (wrongJoinOuter, wrongJoinProof, _) ←
+    match childSystem.prove childJoinIdx wrongJoinChildInput default with
+    | .error e => IO.eprintln s!"wrong join child prove failed: {e}"; return 1
+    | .ok result => pure result
+  let wrongJoinOuterBytes := MultiStark.serializeClaims #[wrongJoinOuter]
+  let wrongJoinProofAdvice ← match childSystem.proofToAdviceBytes
+      wrongJoinOuter wrongJoinProof with
+    | .error e => IO.eprintln s!"wrong join child advice encoding failed: {e}"; return 1
+    | .ok bytes => pure bytes
+  let wrongJoinIo := io
+    |>.extend 0 zeroKey (bytesAsGs wrongJoinProofAdvice)
+    |>.extend 2 zeroKey (bytesAsGs wrongJoinOuterBytes)
+  let wrongTransitiveAllowed :=
+    compiled.bytecode.execute joinIdx pubInput wrongJoinIo
+
+  -- A structural child exposes the same allowed/output public digests as a
+  -- flat child, distinguished only by its pinned function index.
+  let structuralChildInput := MultiStark.joinPubInput allowed structuralClaimBytes
+  let (structuralChildOuter, structuralChildProof, _) ←
+    match childSystem.prove childStructuralJoinIdx structuralChildInput default with
+    | .error e => IO.eprintln s!"structural child prove failed: {e}"; return 1
+    | .ok result => pure result
+  let structuralChildOuterBytes :=
+    MultiStark.serializeClaims #[structuralChildOuter]
+  let structuralChildLayout :=
+    structuralChildOuter.extract 2 10 == MultiStark.digestGs allowed &&
+    structuralChildOuter.extract 10 18 == MultiStark.digestGs structuralClaimBytes
+  let structuralChildNativeVerify :=
+    childSystem.verify structuralChildOuter structuralChildProof
+  let structuralChildProofAdvice ← match childSystem.proofToAdviceBytes
+      structuralChildOuter structuralChildProof with
+    | .error e =>
+      IO.eprintln s!"structural child advice encoding failed: {e}"; return 1
+    | .ok bytes => pure bytes
+
+  -- Structural-of-structural: the left child root is opaque to the parent;
+  -- only its outer proof/claim and assumption tree are opened.
+  let structuralParentOutput :=
+    structuralOutput.joinStructural rightStatement
+  let structuralParentBytes := Ix.Claim.ser structuralParentOutput.claim
+  let structuralParentInput := MultiStark.joinPubInput allowed structuralParentBytes
+  let structuralParentPreimages := MultiStark.joinPreimagesBlob
+    #[structuralClaimBytes, rightInnerClaims, rightClaimBytes]
+  let structuralParentTrees := MultiStark.joinTreesBlob
+    (MultiStark.CheckEnvTrees.structuralAdviceTrees
+      structuralOutput rightStatement structuralParentOutput)
+  let structuralParentPaths := MultiStark.joinPathsBlob
+    (MultiStark.CheckEnvTrees.structuralPathAdvice
+      structuralOutput rightStatement structuralParentOutput)
+  let transitiveStructural := compiled.bytecode.executeMultiStarkJoin
+    structuralJoinIdx structuralParentInput structuralChildProofAdvice
+    rightProofAdvice recursionVk structuralChildOuterBytes rightOuterBytes
+    structuralParentBytes allowed structuralParentPreimages structuralParentTrees
+    structuralParentPaths
+
+  -- A flat join is intentionally unable to re-open this genuinely free-form
+  -- child root as a canonical tree, pinning the monotone mode-ordering rule.
+  let flatAboveStructuralOutput := structuralOutput.join rightStatement
+  let flatAboveStructuralBytes := Ix.Claim.ser flatAboveStructuralOutput.claim
+  let flatAboveStructuralInput :=
+    MultiStark.joinPubInput allowed flatAboveStructuralBytes
+  let flatAboveStructuralTrees := MultiStark.joinTreesBlob
+    (MultiStark.CheckEnvTrees.adviceTrees
+      structuralOutput rightStatement flatAboveStructuralOutput)
+  let flatAboveStructural := compiled.bytecode.executeMultiStarkJoin joinIdx
+    flatAboveStructuralInput structuralChildProofAdvice rightProofAdvice
+    recursionVk structuralChildOuterBytes rightOuterBytes flatAboveStructuralBytes
+    allowed structuralParentPreimages flatAboveStructuralTrees emptyPathsBlob
+
+  -- Digest-consistent semantic failures exercise the set checks rather than
+  -- merely failing the public output-claim hash binding.
+  let omittedAsmBytes := Ix.Claim.ser (.checkEnv outputSubjects.root none)
+  let omittedAsmInput := MultiStark.joinPubInput allowed omittedAsmBytes
+  let omittedAsmIo := io.extend 2 twoKey (bytesAsGs omittedAsmBytes)
+  let omittedAsm := compiled.bytecode.execute joinIdx omittedAsmInput omittedAsmIo
+
+  let extraSubjects := canonicalTree #[a, b, c, e]
+  let extraSubjectBytes := Ix.Claim.ser
+    (.checkEnv extraSubjects.root (some outputAssumptions.root))
+  let extraSubjectInput := MultiStark.joinPubInput allowed extraSubjectBytes
+  let extraSubjectIo := seedJoinTree
+    (io.extend 2 twoKey (bytesAsGs extraSubjectBytes)) extraSubjects
+  let extraSubject :=
+    compiled.bytecode.execute joinIdx extraSubjectInput extraSubjectIo
+
+  -- A free-form tree with the expected leaves in descending order has a
+  -- self-consistent serialization/root pair, but is not a canonical set tree.
+  let sortedOutputLeaves :=
+    (#[a, b, c]).qsort fun x y => compare x y == .lt
+  let unsortedSubjects : Ix.AssumptionTree :=
+    .node (.node (.leaf sortedOutputLeaves[2]!) (.leaf sortedOutputLeaves[1]!))
+      (.leaf sortedOutputLeaves[0]!)
+  let unsortedBytes := Ix.Claim.ser
+    (.checkEnv unsortedSubjects.root (some outputAssumptions.root))
+  let unsortedInput := MultiStark.joinPubInput allowed unsortedBytes
+  let unsortedIo := seedJoinTree
+    (io.extend 2 twoKey (bytesAsGs unsortedBytes)) unsortedSubjects
+  let unsorted := compiled.bytecode.execute joinIdx unsortedInput unsortedIo
+
+  let badLeftProofBytes := leftProofAdvice.set! 0
+    (UInt8.ofNat ((leftProofAdvice.data[0]!.toNat + 1) % 256))
+  let badProofIo := io.extend 0 zeroKey (bytesAsGs badLeftProofBytes)
+  let badProof := compiled.bytecode.execute joinIdx pubInput badProofIo
+
+  -- Run the same two-lift/one-join proof DAG through the WP-B executor at
+  -- jobs=1 and jobs=2. Both leaves are admitted together in the parallel run,
+  -- exercising concurrent calls through the same Aiur prover used by the
+  -- production wrapper; the stand-in bytecode deliberately uses the ordinary
+  -- witness path because the specialized MultiStark witness builder has a
+  -- fixed production input shape. Use zero query PoW here because the pinned
+  -- dependency's positive-PoW grind legitimately returns whichever passing
+  -- witness rayon finds first, making even repeated serial proof bytes differ.
+  -- Zero PoW has a canonical witness, so complete-wrapper equality isolates
+  -- scheduling determinism rather than PoW-search nondeterminism.
+  let scheduledProofSystem := AiurSystem.build childCompiled.bytecode
+    recCommitParams { innerFri with queryProofOfWorkBits := 0 }
+  let scheduledProofSlot (slotIdx : Nat)
+      (slots : Array (Option ByteArray)) : IO (Except String ByteArray) := do
+    match slotIdx with
+    | 0 | 1 =>
+      let claimsBytes := if slotIdx == 0 then leftInnerClaims else rightInnerClaims
+      let expectedOuter := if slotIdx == 0 then leftOuter else rightOuter
+      let liftInput := MultiStark.verifierPubInput fakeIxvmVk claimsBytes
+      let (outer, proof, _) ← match scheduledProofSystem.prove liftIdx liftInput default with
+        | .error e => return .error e
+        | .ok result => pure result
+      if outer != expectedOuter then return .error "scheduled lift claim mismatch"
+      pure (.ok proof.toBytes)
+    | 2 =>
+      let some leftBytes := (slots[0]?).join
+        | return .error "scheduled join missing left proof"
+      let some rightBytes := (slots[1]?).join
+        | return .error "scheduled join missing right proof"
+      let leftProof ← match Aiur.Proof.ofBytesChecked leftBytes with
+        | .error e => return .error e
+        | .ok proof => pure proof
+      let rightProof ← match Aiur.Proof.ofBytesChecked rightBytes with
+        | .error e => return .error e
+        | .ok proof => pure proof
+      match scheduledProofSystem.verify leftOuter leftProof,
+          scheduledProofSystem.verify rightOuter rightProof with
+      | .ok (), .ok () => pure ()
+      | .error e, _ | _, .error e => return .error e
+      let (outer, proof, _) ←
+        match scheduledProofSystem.prove childJoinIdx pubInput default with
+        | .error e => return .error e
+        | .ok result => pure result
+      if outer != Aiur.buildClaim childJoinIdx pubInput #[] then
+        return .error "scheduled join claim mismatch"
+      pure (.ok proof.toBytes)
+    | _ => pure (.error "unexpected scheduled proof slot")
+  let scheduledWrapperBytes (proofs : Array ByteArray) : Array ByteArray :=
+    proofs.mapIdx fun slotIdx proof =>
+      let claim := if slotIdx == 0 then leftStatement.claim
+        else if slotIdx == 1 then rightStatement.claim
+        else outputStatement.claim
+      Ixon.Proof.ser { claim, proof }
+  let serialScheduledProofs ← Ix.Cli.AggregateCmd.runAggregateDag cachePlan
+    #[8, 8, 4] 1 16 scheduledProofSlot
+  let parallelScheduledProofs ← Ix.Cli.AggregateCmd.runAggregateDag cachePlan
+    #[8, 8, 4] 2 16 scheduledProofSlot
+  let parallelProofWrappersStable ←
+    match serialScheduledProofs, parallelScheduledProofs with
+    | .ok serial, .ok parallel =>
+      let serialWrappers := scheduledWrapperBytes serial
+      let parallelWrappers := scheduledWrapperBytes parallel
+      if serialWrappers != parallelWrappers then
+        IO.eprintln s!"scheduled proof mismatch: serial={serialWrappers.map Address.blake3}, \
+          parallel={parallelWrappers.map Address.blake3}"
+      pure (serialWrappers == parallelWrappers)
+    | .error e, _ =>
+      IO.eprintln s!"serial scheduled proof failed: {e}"
+      pure false
+    | _, .error e =>
+      IO.eprintln s!"parallel scheduled proof failed: {e}"
+      pure false
+
+  let hostFoldCorrect :=
+    outputSubjects.leaves == (canonicalTree #[a, b, c]).leaves &&
+    outputStatement.assumptions.map (·.leaves) == some (canonicalTree #[d]).leaves
+  let manifestPlan :=
+    (Ix.Cli.CheckCmd.AggregationTree.node
+      (.node (.leaf 0) (.leaf 1)) (.leaf 2)).foldPlan
+  let expectedPlan : Array Ix.Cli.CheckCmd.AggregationTree.FoldOp :=
+    #[.leaf 0, .leaf 1, .join 0 1, .leaf 2, .join 2 3]
+  let parsedManifestPlan : Bool :=
+    let valid := minimalIxes (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 1)
+    match Ix.Cli.CheckCmd.parseIxesManifest valid with
+    | .ok view => view.aggregationTree.foldPlan ==
+      (#[.leaf 0, .leaf 1, .join 0 1] :
+        Array Ix.Cli.CheckCmd.AggregationTree.FoldOp)
+    | .error _ => false
+  let malformedManifestRejected : Bool :=
+    let duplicate := minimalIxes (#[1, 1, 0] ++ u32le4 0 ++ #[0] ++ u32le4 0)
+    match Ix.Cli.CheckCmd.parseIxesManifest duplicate with
+    | .error _ => true
+    | .ok _ => false
+  let (singleEnv, singleAddr) := singletonIxonEnv
+  let singleTreeTail := #[1, 1, 0] ++ u32le4 0 ++ #[1, 0] ++
+    u32le4 1 ++ #[0] ++ u32le4 2
+  let singleManifest := Ix.Cli.CheckCmd.parseIxesManifest
+    (minimalIxesFor #[#[], #[singleAddr], #[]] singleTreeTail)
+  let singleCoverage ← match singleManifest with
+    | .ok view => Ix.Cli.CheckCmd.shardsCover singleEnv view.shards
+    | .error _ => pure false
+  let emptyPruningCorrect : Bool := match singleManifest with
+    | .ok view => match view.pruneEmpty singleEnv with
+      | .ok (pruned, counts) =>
+        pruned.shards == #[#[singleAddr]] && pruned.shardIds == #[1] &&
+          pruned.aggregationTree == .leaf 0 && counts == #[1]
+      | .error _ => false
+    | .error _ => false
+  let singleManifestValueRoot : Bool := match singleManifest with
+    | .ok view => match Ix.Cli.VerifyCmd.expectedFromManifest singleEnv view 0 with
+      | .ok statement =>
+        statement.claim == .checkEnv (canonicalTree #[singleAddr]).root none
+      | _ => false
+    | .error _ => false
+  let shardPrepPreservesSemantics : Bool :=
+    let (sharedEnv, owned, sharedAddress) := sharedClosureIxonEnv
+    let legacyClosure : Std.HashSet Address := Id.run do
+      let mut closure : Std.HashSet Address := {}
+      for address in owned do
+        closure := closure.union
+          (IxVM.ClaimHarness.closureFrom sharedEnv address)
+      return closure
+    let expectedOwned := canonicalTree owned
+    let expectedFrontier := canonicalTree #[sharedAddress]
+    match IxVM.ClaimHarness.shardCheckEnvClaimTrees sharedEnv owned,
+        IxVM.ClaimHarness.shardCheckEnvClaim sharedEnv owned with
+    | .ok (claimOnly, treesOnly), .ok (claimFull, closure, treesFull) =>
+      let sameClosure := closure.size == legacyClosure.size &&
+        closure.toArray.all legacyClosure.contains
+      claimOnly == .checkEnv expectedOwned.root (some expectedFrontier.root) &&
+        claimFull == claimOnly && sameClosure &&
+        treesOnly.size == 2 && treesFull.size == 2 &&
+        treesOnly.contains expectedOwned.root &&
+        treesOnly.contains expectedFrontier.root &&
+        treesFull.contains expectedOwned.root &&
+        treesFull.contains expectedFrontier.root
+    | _, _ => false
+  let mixedScheduleCorrect : Bool :=
+    match Ix.Cli.AggregateCmd.schedulePlan manifestPlan #[2, 2, 1] 4 with
+    | .ok scheduled =>
+      match scheduled[2]?, scheduled[4]? with
+      | some lower, some upper =>
+        scheduled.size == 5 && lower.subjectCount == 4 && !lower.structural &&
+          upper.subjectCount == 5 && upper.structural
+      | _, _ => false
+    | .error _ => false
+
+  -- WP-B's pure admission gate: three leaves are initially ready, but the
+  -- heaviest 8-byte stand-in occupies the 10-byte budget alone. Once it
+  -- completes, the 6- and 3-byte leaves run together; joins become eligible
+  -- only after both declared children complete.
+  let schedulerPlan := Ix.Cli.AggregateCmd.schedulePlan
+    manifestPlan #[2, 2, 1] 4
+  let fakeWeights : Array Nat := #[8, 3, 4, 6, 5]
+  let schedulerTrace := schedulerPlan.bind fun scheduled =>
+    Ix.Cli.AggregateCmd.simulateAggregateSchedule scheduled fakeWeights 2 10
+  let schedulerHeaviestFirst : Bool := match schedulerTrace with
+    | .ok trace =>
+      trace.admissionOrder == #[0, 3, 1, 2, 4] &&
+        trace.admissionBatches == #[#[0], #[3, 1], #[2], #[4]]
+    | .error _ => false
+  let schedulerWithinLimits : Bool := match schedulerTrace with
+    | .ok trace =>
+      trace.maxReservedBytes <= 10 &&
+        trace.admissionBatches.all (fun batch => batch.size <= 2)
+    | .error _ => false
+  let schedulerDependenciesHold : Bool := match schedulerTrace with
+    | .ok trace =>
+      let position (slot : Nat) := trace.admissionOrder.findIdx? (· == slot)
+      match position 0, position 1, position 2, position 3, position 4 with
+      | some p0, some p1, some p2, some p3, some p4 =>
+        p0 < p2 && p1 < p2 && p2 < p4 && p3 < p4
+      | _, _, _, _, _ => false
+    | .error _ => false
+  let oversizedRunsAlone : Bool := match schedulerPlan.bind fun scheduled =>
+      Ix.Cli.AggregateCmd.simulateAggregateSchedule scheduled
+        #[11, 3, 4, 6, 5] 2 10 with
+    | .ok trace => trace.admissionBatches[0]? == some #[0] &&
+        trace.admissionBatches.all fun batch =>
+          batch.size == 1 || batch.all fun slot => fakeWeights[slot]! <= 10
+    | .error _ => false
+  let flatWeightAffine :=
+    Ix.Cli.AggregateCmd.aggregateSlotRamBytes
+      { op := .join 0 1, subjectCount := 7, structural := false } ==
+      Ix.Cli.AggregateCmd.aggregateStructuralJoinRamBytes +
+        7 * Ix.Cli.AggregateCmd.aggregateFlatJoinRamPerSubjectBytes
+  let memTotalParsing :=
+    Ix.Cli.AggregateCmd.aggregateMemTotalBytes
+      "MemTotal:       1024 kB\nMemFree: 512 kB\n" == some (1024 * 1024)
+
+  -- Exercise the actual task/channel executor at jobs=1 and jobs=2. The fake
+  -- payload is content-derived exactly like a wrapper: leaves encode their
+  -- shard and slot, while joins concatenate both completed child payloads.
+  let fakeRun (scheduled : Array Ix.Cli.AggregateCmd.ScheduledFold)
+      (slotIdx : Nat) (slots : Array (Option ByteArray)) :
+      IO (Except String ByteArray) := do
+    let some item := scheduled[slotIdx]?
+      | return .error "missing fake slot"
+    match item.op with
+    | .leaf shard =>
+      pure (.ok ⟨#[UInt8.ofNat shard, UInt8.ofNat slotIdx]⟩)
+    | .join left right =>
+      let some leftBytes := (slots[left]?).join
+        | return .error "missing fake left child"
+      let some rightBytes := (slots[right]?).join
+        | return .error "missing fake right child"
+      pure (.ok ((leftBytes ++ rightBytes).push (UInt8.ofNat slotIdx)))
+  let schedulerSerialParallelParity ← match schedulerPlan with
+    | .error _ => pure false
+    | .ok scheduled =>
+      let serial ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        1 10 (fakeRun scheduled)
+      let parallel ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        2 10 (fakeRun scheduled)
+      pure <| match serial, parallel with
+        | .ok serial, .ok parallel => serial == parallel
+        | _, _ => false
+  let dependentStarted ← IO.mkRef false
+  let failureRun (slotIdx : Nat) (_ : Array (Option Nat)) :
+      IO (Except String Nat) := do
+    if slotIdx == 0 then return .error "intentional leaf failure"
+    if slotIdx == 2 then dependentStarted.set true
+    pure (.ok slotIdx)
+  let schedulerStopsAfterFailure ← match schedulerPlan with
+    | .error _ => pure false
+    | .ok scheduled =>
+      let result ← Ix.Cli.AggregateCmd.runAggregateDag scheduled fakeWeights
+        2 10 failureRun
+      let started ← dependentStarted.get
+      pure <| match result with
+        | .error e => e.startsWith "slot 0: intentional leaf failure" && !started
+        | .ok _ => false
+
+  lspecIO (.ofList [("aggregate-first", [
+    test "default recursion parameters preserve the legacy verifying key"
+      defaultRecursionIdentityPreserved,
+    test "recursion FRI cache encoding is the pinned 40-byte layout"
+      defaultFriEncodingStable,
+    test "FRI and commitment overrides independently change recursion identity"
+      recursionParametersIndependent,
+    test "aggregate cache key binds version, recursion vk, FRI params, and outer claim"
+      cacheKeyInputsBound,
+    test "aggregate cache index atomically round-trips a store address"
+      cacheIndexRoundTrip,
+    test "aggregate cache treats a corrupt index as an invalid hint"
+      corruptCacheIndexRejected,
+    test "aggregate cache atomically replaces a corrupt index after re-proving"
+      corruptCacheIndexRecovers,
+    test "aggregate cache resumes from a content-addressed verified wrapper"
+      verifiedResumeHit,
+    test "aggregate cache treats corrupt store content as a miss"
+      corruptStoreFallsThrough,
+    expectOk "aggregate cache accepts an exactly bound valid wrapper"
+      validCachedLift,
+    expectErr "aggregate cache rejects a wrapper for a different CheckEnv"
+      wrongCachedStatement,
+    expectErr "aggregate cache rejects a proof under a different outer claim"
+      wrongCachedOuterClaim,
+    expectErr "aggregate cache rejects a corrupted proof"
+      badCachedProof,
+    test "host fold constructs canonical union/discharge trees" hostFoldCorrect,
+    test "manifest tree lowers to post-order binary slots" (manifestPlan == expectedPlan),
+    test "manifest parser exposes its validated bisection tree" parsedManifestPlan,
+    test "manifest parser rejects repeated aggregation leaves" malformedManifestRejected,
+    test "coverage accepts legacy zero-constant manifest leaves" singleCoverage,
+    test "empty manifest leaves contract and retained ids remap densely"
+      emptyPruningCorrect,
+    test "one retained shard reconstructs one value-based root"
+      singleManifestValueRoot,
+    test "shard claim-only prep preserves trees and one-pass closure semantics"
+      shardPrepPreservesSemantics,
+    test "stand-in lift/flat/structural entrypoints survive compiler dedup separately"
+      (liftIdx != childJoinIdx && liftIdx != childStructuralJoinIdx &&
+        childJoinIdx != childStructuralJoinIdx),
+    test "aggregate verifier reconstructs the single-shard lift claim"
+      liftClaimReconstruction,
+    expectOk "reconstructed single-shard lift root verifies natively"
+      reconstructedLiftVerifies,
+    expectOk "join accepts canonical union and cross-child discharge" honest,
+    test "join child outer claim carries allowed/output digests" joinChildLayout,
+    expectOk "stand-in join child proof verifies natively" joinChildNativeVerify,
+    expectOk "join accepts a transitively pinned join child" transitiveJoin,
+    expectErr "join rejects a join child with a different allowed digest"
+      wrongTransitiveAllowed,
+    test "structural host fold is root-of-roots with canonical survivors"
+      structuralHostCorrect,
+    expectOk "structural join accepts path discharge plus one carried assumption"
+      structuralHonest,
+    test "codegen'd structural join matches interpreter (output + query counts)"
+      structuralParity,
+    test "structural child outer claim carries allowed/output digests"
+      structuralChildLayout,
+    expectOk "stand-in structural child proof verifies natively"
+      structuralChildNativeVerify,
+    expectOk "structural join accepts a transitively pinned structural child"
+      transitiveStructural,
+    test "threshold scheduling is flat below and structural above monotonically"
+      mixedScheduleCorrect,
+    test "RAM-gated scheduler admits ready work heaviest-first"
+      schedulerHeaviestFirst,
+    test "RAM-gated scheduler respects job and byte budgets"
+      schedulerWithinLimits,
+    test "RAM-gated scheduler never admits joins before both children"
+      schedulerDependenciesHold,
+    test "an individually oversized scheduler slot is admitted alone"
+      oversizedRunsAlone,
+    test "flat-join RAM reserve is affine in subject leaves"
+      flatWeightAffine,
+    test "aggregate scheduler parses MemTotal for its default budget"
+      memTotalParsing,
+    test "jobs=2 DAG execution is byte-identical to jobs=1"
+      schedulerSerialParallelParity,
+    test "a failed slot drains peers without starting dependent joins"
+      schedulerStopsAfterFailure,
+    test "jobs=2 zero-PoW proof wrappers are byte-identical to jobs=1"
+      parallelProofWrappersStable,
+    expectErr "structural join rejects a path to the wrong root" wrongRootPath,
+    expectErr "structural join rejects a tampered path sibling" tamperedPath,
+    expectErr "structural join rejects a candidate with no path choice"
+      droppedAssumption,
+    expectErr "structural join rejects a carried assumption missing from output"
+      missingCarried,
+    expectErr "structural join rejects the old 88-byte allowed blob"
+      oldAllowedRejected,
+    expectErr "flat join rejects a genuinely structural child subject root"
+      flatAboveStructural,
+    test "codegen'd join matches interpreter (output + query counts)" nativeParity,
+    expectErr "native join rejects malformed keyed-blob framing" malformedFraming,
+    expectErr "join rejects an omitted undischarged assumption" omittedAsm,
+    expectErr "join rejects an extra output subject" extraSubject,
+    expectErr "join rejects an unsorted output subject tree" unsorted,
+    expectErr "join rejects a tampered child proof" badProof,
+  ])]) []
+
 end Tests.MultiStark
 
 end
diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs
index 26488ce50..f4a708cca 100644
--- a/crates/aiur/src/constraints.rs
+++ b/crates/aiur/src/constraints.rs
@@ -164,7 +164,10 @@ impl Toplevel {
 }
 
 fn empty_lookup() -> Lookup<Expr> {
-  Lookup { multiplicity: konst(G::ZERO), args: vec![] }
+  // Slots accumulate mutually-exclusive branch selectors, so the per-row
+  // multiplicity is 0 or ±1; the function's return slot (a committed count
+  // column) overrides this with `COUNT_COLUMN_BUDGET`.
+  Lookup { multiplicity: konst(G::ZERO), args: vec![], max_multiplicity: 1 }
 }
 
 impl Function {
@@ -182,6 +185,7 @@ impl Function {
     state.column += 1;
     // the return lookup occupies the first lookup slot
     state.lookups[0].multiplicity = -multiplicity.clone();
+    state.lookups[0].max_multiplicity = crate::COUNT_COLUMN_BUDGET;
     state.lookup += 1;
     self.body.collect_constraints(self.body.get_block_selector(state), state);
   }
diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs
index 3037a1d52..2adbf48d9 100644
--- a/crates/aiur/src/execute.rs
+++ b/crates/aiur/src/execute.rs
@@ -33,23 +33,48 @@ pub struct QueryRecord {
   pub memory_queries: FxIndexMap<usize, QueryMap>,
   pub bytes1_queries: Bytes1Queries,
   pub bytes2_queries: Bytes2Queries,
+  /// Virtual-gas meter: sum of circuit-width-priced constrained query
+  /// touches, with memo hits replaying the callee's recorded span — the
+  /// cost of the execution as if nothing were memoized. Never read
+  /// directly; frame deltas of it become the per-entry spans that
+  /// `QueryMap::finish` records (surfaced via `QueryRecordHandle`).
+  pub virt: u64,
 }
 
 impl QueryRecord {
-  pub fn new(toplevel: &Toplevel) -> Self {
+  /// `profile` enables per-entry virtual-span recording (readable through
+  /// the `QueryRecordHandle` FFI accessors); plumbed from the execution
+  /// entrypoint.
+  pub fn new(toplevel: &Toplevel, profile: bool) -> Self {
+    // Weight = committed main-trace width, the per-touch price of a row.
+    // Unconstrained functions have no circuit, so their rows are free.
     let function_queries = toplevel
       .functions
       .iter()
-      .map(|f| QueryMap::new(f.layout.input_size))
+      .map(|f| {
+        let weight = if f.constrained { f.layout.width() as u64 } else { 0 };
+        QueryMap::new(f.layout.input_size, weight, profile)
+      })
       .collect();
     let memory_queries = toplevel
       .memory_sizes
       .iter()
-      .map(|width| (*width, QueryMap::new(*width)))
+      .map(|width| {
+        // Memory circuit width: multiplicity, selector, pointer, values.
+        // Memory maps never record spans (their replay cost is the
+        // weight itself), so the profile flag is irrelevant here.
+        (*width, QueryMap::new(*width, (3 + *width) as u64, false))
+      })
       .collect();
     let bytes1_queries = Bytes1Queries::new();
     let bytes2_queries = Bytes2Queries::new();
-    Self { function_queries, memory_queries, bytes1_queries, bytes2_queries }
+    Self {
+      function_queries,
+      memory_queries,
+      bytes1_queries,
+      bytes2_queries,
+      virt: 0,
+    }
   }
 }
 
@@ -209,7 +234,7 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) {
     .map(|(i, m)| (i, m.len(), m.retained_elems()))
     .filter(|(_, n, _)| *n > 0)
     .collect();
-  rows.sort_by(|a, b| b.2.cmp(&a.2));
+  rows.sort_by_key(|r| std::cmp::Reverse(r.2));
   let total_entries: usize = rows.iter().map(|r| r.1).sum();
   let total_elems: usize = rows.iter().map(|r| r.2).sum();
   eprintln!(
@@ -228,16 +253,19 @@ fn dump_query_stats(record: &QueryRecord, tag: &str) {
 }
 
 impl Toplevel {
+  /// `profile` enables per-entry virtual-span recording on the returned
+  /// `QueryRecord` (see `QueryMap::finish`).
   pub fn execute(
     &self,
     fun_idx: FunIdx,
     args: Vec<G>,
     io_buffer: &mut IOBuffer,
+    profile: bool,
   ) -> Result<(QueryRecord, Vec<G>), ExecError> {
     if !self.functions[fun_idx].entry {
       return Err(ExecError::NotEntryFunction(fun_idx));
     }
-    let mut record = QueryRecord::new(self);
+    let mut record = QueryRecord::new(self, profile);
     let function = &self.functions[fun_idx];
     let output =
       function.execute(fun_idx, args, self, &mut record, io_buffer)?;
@@ -258,6 +286,9 @@ struct CallerState {
   map: Vec<G>,
   unconstrained: bool,
   continuation_depth: usize,
+  /// `record.virt` at callee entry; the callee's `Ctrl::Return` reads it
+  /// to record the frame's virtual span on the registered entry.
+  vsnap: u64,
 }
 
 struct ContinuationState<'a> {
@@ -328,23 +359,26 @@ impl Function {
         ExecEntry::Op(Op::Call(callee_idx, args, _, op_unconstrained)) => {
           let args: Vec<G> = args.iter().map(|i| map[*i]).collect();
           let callee_unconstrained = unconstrained || *op_unconstrained;
-          let cached_output = record.function_queries[*callee_idx]
-            .get_mut(&args)
-            .and_then(|result| {
-              // A zero-multiplicity entry was computed only as an
-              // unconstrained hint.  Promoting just this row would omit all
-              // of the callee's child lookups and unbalance their channels;
-              // replay the body constrained so promotion recurses through
-              // the whole dependency tree.
-              if !callee_unconstrained && result.multiplicity.is_zero() {
-                None
-              } else {
-                if !callee_unconstrained {
-                  *result.multiplicity += G::ONE;
-                }
-                Some(result.output.to_vec())
+          let mut cached_output = None;
+          if let Some(i) =
+            record.function_queries[*callee_idx].get_index_of(&args)
+          {
+            // A zero-multiplicity entry was computed only as an
+            // unconstrained hint.  Promoting just this row would omit all
+            // of the callee's child lookups and unbalance their channels;
+            // replay the body constrained so promotion recurses through
+            // the whole dependency tree.
+            let mult = record.function_queries[*callee_idx].mult_at(i);
+            if callee_unconstrained || !mult.is_zero() {
+              if !callee_unconstrained {
+                let replay = record.function_queries[*callee_idx].replay_at(i);
+                record.virt += replay;
               }
-            });
+              cached_output = Some(
+                record.function_queries[*callee_idx].output_at(i).to_vec(),
+              );
+            }
+          }
           if let Some(output) = cached_output {
             map.extend(output);
           } else {
@@ -354,6 +388,7 @@ impl Function {
               map: saved_map,
               unconstrained,
               continuation_depth: continuation_stack.len(),
+              vsnap: record.virt,
             });
             fun_idx = *callee_idx;
             unconstrained = callee_unconstrained;
@@ -367,11 +402,11 @@ impl Function {
             .memory_queries
             .get_mut(&size)
             .ok_or(ExecError::InvalidMemorySize(size))?;
-          if let Some(result) = memory_queries.get_mut(&values) {
+          if let Some(i) = memory_queries.get_index_of(&values) {
             if !unconstrained {
-              *result.multiplicity += G::ONE;
+              record.virt += memory_queries.replay_at(i);
             }
-            map.extend_from_slice(result.output);
+            map.extend_from_slice(memory_queries.output_at(i));
           } else {
             let ptr = G::from_usize(memory_queries.len());
             memory_queries.insert(
@@ -379,6 +414,9 @@ impl Function {
               &[ptr],
               G::from_bool(!unconstrained),
             );
+            if !unconstrained {
+              record.virt += memory_queries.weight();
+            }
             map.push(ptr);
           }
         },
@@ -392,12 +430,17 @@ impl Function {
           let ptr_usize = usize::try_from(ptr_u64)
             .ok()
             .ok_or(ExecError::PointerTooLarge(ptr_u64))?;
-          let (args, multiplicity) = memory_queries
-            .get_index_mut(ptr_usize)
-            .ok_or(ExecError::UnboundPointer { ptr: ptr_u64, size: *size })?;
+          if ptr_usize >= memory_queries.len() {
+            return Err(ExecError::UnboundPointer {
+              ptr: ptr_u64,
+              size: *size,
+            });
+          }
           if !unconstrained {
-            *multiplicity += G::ONE;
+            record.virt += memory_queries.replay_at(ptr_usize);
           }
+          let (args, _) =
+            memory_queries.get_index(ptr_usize).expect("bounds checked above");
           map.extend_from_slice(args);
         },
         ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => {
@@ -709,30 +752,27 @@ impl Function {
           push_block_exec_entries!(cont.block);
         },
         ExecEntry::Ctrl(Ctrl::Return(_, output)) => {
-          // Register the query.
+          // Register the query, pricing the row's own touch and recording
+          // the frame's virtual span (own touch + child work, memo hits
+          // replayed) on the entry.
           let input_size = toplevel.functions[fun_idx].layout.input_size;
           let output = output.iter().map(|i| map[*i]).collect::<Vec<_>>();
-          if let Some(result) =
-            record.function_queries[fun_idx].get_mut(&map[..input_size])
-          {
-            // The only ordinary way to execute an already cached function
-            // is constrained promotion of an unconstrained hint entry.
-            debug_assert_eq!(result.output, output);
-            if !unconstrained {
-              *result.multiplicity += G::ONE;
-            }
-          } else {
-            record.function_queries[fun_idx].insert(
-              &map[..input_size],
-              &output,
-              G::from_bool(!unconstrained),
-            );
+          if !unconstrained {
+            record.virt += record.function_queries[fun_idx].weight();
           }
+          let vsnap = callers_states_stack.last().map_or(0, |cs| cs.vsnap);
+          record.function_queries[fun_idx].finish(
+            &map[..input_size],
+            &output,
+            !unconstrained,
+            record.virt - vsnap,
+          );
           if let Some(CallerState {
             fun_idx: caller_idx,
             map: caller_map,
             unconstrained: caller_unconstrained,
             continuation_depth,
+            vsnap: _,
           }) = callers_states_stack.pop()
           {
             continuation_stack.truncate(continuation_depth);
@@ -1052,14 +1092,7 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec<u64> {
   while !bytes.len().is_multiple_of(8) {
     bytes.push(0);
   }
-  bytes
-    .chunks_exact(8)
-    .map(|c| {
-      let mut a = [0u8; 8];
-      a.copy_from_slice(c);
-      u64::from_le_bytes(a)
-    })
-    .collect()
+  bytes.as_chunks::<8>().0.iter().map(|c| u64::from_le_bytes(*c)).collect()
 }
 
 /// Build a `List<U64>` chain in `memory[10]` from `limbs` (head-first order)
diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs
index 667cb8ad9..4765ca953 100644
--- a/crates/aiur/src/gadgets/bytes1.rs
+++ b/crates/aiur/src/gadgets/bytes1.rs
@@ -49,8 +49,12 @@ impl AiurGadget for Bytes1 {
   /// Builds the preprocessed trace over all 256 byte values.
   fn preprocessed(&self) -> Option<RowMajorMatrix<G>> {
     let mut values = vec![G::ZERO; 256 * PREPROCESSED_TRACE_WIDTH];
-    values.chunks_exact_mut(PREPROCESSED_TRACE_WIDTH).enumerate().for_each(
-      |(i, row)| {
+    values
+      .as_chunks_mut::<PREPROCESSED_TRACE_WIDTH>()
+      .0
+      .iter_mut()
+      .enumerate()
+      .for_each(|(i, row)| {
         let byte = G::from_usize(i);
 
         // Raw byte value
@@ -68,8 +72,7 @@ impl AiurGadget for Bytes1 {
 
         // Byte shifted right
         row[10] = Self::shift_right(&byte);
-      },
-    );
+      });
     Some(RowMajorMatrix::new(values, PREPROCESSED_TRACE_WIDTH))
   }
 
@@ -136,16 +139,19 @@ impl AiurGadget for Bytes1 {
         byte_bit6,
         byte_bit7,
       ],
+      max_multiplicity: crate::COUNT_COLUMN_BUDGET,
     };
 
     let pull_shift_left = Lookup {
       multiplicity: -shift_left_multiplicity,
       args: vec![shift_left_channel, byte.clone(), byte_left_shifted],
+      max_multiplicity: crate::COUNT_COLUMN_BUDGET,
     };
 
     let pull_shift_right = Lookup {
       multiplicity: -shift_right_multiplicity,
       args: vec![shift_right_channel, byte, byte_right_shifted],
+      max_multiplicity: crate::COUNT_COLUMN_BUDGET,
     };
 
     vec![pull_bit_decomposition, pull_shift_left, pull_shift_right]
@@ -168,7 +174,9 @@ impl AiurGadget for Bytes1 {
 
     // There are at most 256 rows so parallelism is not necessay.
     rows
-      .chunks_exact_mut(TRACE_WIDTH)
+      .as_chunks_mut::<TRACE_WIDTH>()
+      .0
+      .iter_mut()
       .enumerate()
       .zip(&record.bytes1_queries.0)
       .zip(row_writers.iter_mut())
diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs
index 8a2e16ef4..e9e03d364 100644
--- a/crates/aiur/src/gadgets/bytes2.rs
+++ b/crates/aiur/src/gadgets/bytes2.rs
@@ -211,45 +211,54 @@ impl AiurGadget for Bytes2 {
     let xor_split4_hi = Expr::preprocessed(12);
     let xor_split4_lo = Expr::preprocessed(13);
 
-    // pull = negated multiplicity.
+    // pull = negated multiplicity; count columns declare the query budget.
+    let budget = crate::COUNT_COLUMN_BUDGET;
     let pull_xor = Lookup {
       multiplicity: -xor_multiplicity,
       args: vec![xor_channel, i.clone(), j.clone(), xor],
+      max_multiplicity: budget,
     };
 
     let pull_add = Lookup {
       multiplicity: -add_multiplicity,
       args: vec![add_channel, i.clone(), j.clone(), add_r],
+      max_multiplicity: budget,
     };
 
     let pull_sub = Lookup {
       multiplicity: -sub_multiplicity,
       args: vec![sub_channel, i.clone(), j.clone(), sub_r],
+      max_multiplicity: budget,
     };
 
     let pull_and = Lookup {
       multiplicity: -and_multiplicity,
       args: vec![and_channel, i.clone(), j.clone(), and],
+      max_multiplicity: budget,
     };
 
     let pull_or = Lookup {
       multiplicity: -or_multiplicity,
       args: vec![or_channel, i.clone(), j.clone(), or],
+      max_multiplicity: budget,
     };
 
     let pull_less_than = Lookup {
       multiplicity: -less_than_multiplicity,
       args: vec![less_than_channel, i.clone(), j.clone(), less_than],
+      max_multiplicity: budget,
     };
 
     let pull_mul = Lookup {
       multiplicity: -mul_multiplicity,
       args: vec![mul_channel, i.clone(), j.clone(), mul_lo, mul_hi],
+      max_multiplicity: budget,
     };
 
     let pull_range_check = Lookup {
       multiplicity: -range_check_multiplicity,
       args: vec![range_check_channel, i.clone(), j.clone()],
+      max_multiplicity: budget,
     };
 
     let pull_xor_split7 = Lookup {
@@ -261,10 +270,12 @@ impl AiurGadget for Bytes2 {
         xor_split7_hi,
         xor_split7_lo,
       ],
+      max_multiplicity: budget,
     };
     let pull_xor_split4 = Lookup {
       multiplicity: -xor_split4_multiplicity,
       args: vec![xor_split4_channel, i, j, xor_split4_hi, xor_split4_lo],
+      max_multiplicity: budget,
     };
 
     vec![
@@ -304,7 +315,9 @@ impl AiurGadget for Bytes2 {
     let xor_split4_channel = u8_xor_split4_channel();
 
     rows
-      .chunks_exact_mut(TRACE_WIDTH)
+      .as_chunks_mut::<TRACE_WIDTH>()
+      .0
+      .iter_mut()
       .enumerate()
       .zip(&record.bytes2_queries.0)
       .zip(row_writers.iter_mut())
diff --git a/crates/aiur/src/lib.rs b/crates/aiur/src/lib.rs
index 3acf6666a..f915d1e43 100644
--- a/crates/aiur/src/lib.rs
+++ b/crates/aiur/src/lib.rs
@@ -15,6 +15,39 @@ use rustc_hash::FxBuildHasher;
 pub type G = multi_stark::p3_goldilocks::Goldilocks;
 pub type FxIndexMap<K, V> = IndexMap<K, V, FxBuildHasher>;
 
+/// Per-row multiplicity budget declared for committed count columns —
+/// function-call return counts, memory load counts, and gadget table
+/// counts: each entry supports up to 2^32 queries. The columns are not
+/// range-constrained; the weight-1 pushes at the query sites are what keep
+/// actual counts within the budget. Feeds the logUp height bound
+/// `Σ wᵢ·hᵢ + |claims| < p` (see `multi_stark::lookup::Lookup`'s
+/// `max_multiplicity`).
+pub const COUNT_COLUMN_BUDGET: u64 = 1 << 32;
+
+/// # Channel discipline (width binding by construction)
+///
+/// Aiur declares `WidthBinding::ByConstruction` to multi-stark: message
+/// fingerprints are the plain Horner fold, so a message equals its own
+/// zero-padding. That is what licenses branch-shared lookup slots — with
+/// mutually exclusive selectors, sibling branches superpose messages of
+/// different natural widths into one slot at the maximum width, and the
+/// padded send still matches its natural-width provider.
+///
+/// The contract this declaration takes on is prefix-freeness: every
+/// message's natural width must be a function of its constant-constrained
+/// leading prefix, so zero-extension can only ever equate a padded message
+/// with its own natural form. The channels below uphold it —
+///
+/// - function channel: `[tag, fun_idx, inputs.., outputs..]`, width
+///   `2 + in + out` fixed by `fun_idx`;
+/// - memory channel: `[tag, size, ptr, values..]`, width `3 + size` fixed
+///   by the size coordinate;
+/// - gadget channels: one fixed width per tag (each byte-table op has its
+///   own channel).
+///
+/// Every op that emits a lookup gates these leading coordinates as
+/// constants, so a new channel (or a new width for an existing one) must
+/// keep the width derivable from the prefix.
 #[inline]
 pub const fn function_channel() -> G {
   G::ZERO
diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs
index c3fd487d0..38550a1ee 100644
--- a/crates/aiur/src/memory.rs
+++ b/crates/aiur/src/memory.rs
@@ -46,7 +46,11 @@ impl Memory {
     }
     let width = Self::width(size);
     // pull = negated multiplicity.
-    let lookups = vec![Lookup { multiplicity: -multiplicity, args }];
+    let lookups = vec![Lookup {
+      multiplicity: -multiplicity,
+      args,
+      max_multiplicity: crate::COUNT_COLUMN_BUDGET,
+    }];
 
     // Transition constraints (formerly the `Air::eval` body): the selector is
     // boolean; a real next row implies a real current row; and the pointer
diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs
index 56f97306e..94de70f93 100644
--- a/crates/aiur/src/querymap.rs
+++ b/crates/aiur/src/querymap.rs
@@ -1,4 +1,4 @@
-use multi_stark::p3_field::PrimeField64;
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 
 use crate::G;
 
@@ -196,16 +196,17 @@ impl SegStore {
   }
 }
 
-/// Segmented store of per-entry key hashes. Kept so hash-table growth can
-/// re-insert from stored hashes instead of re-hashing every key from the
-/// keys arena — table doubling on a multi-GB map used to be a full
-/// sequential re-hash pass over the arena, log-many times.
-struct SegHashes {
+/// Segmented store of per-entry `u64`s. Used for the key hashes — kept so
+/// hash-table growth can re-insert from stored hashes instead of
+/// re-hashing every key from the keys arena (table doubling on a multi-GB
+/// map used to be a full sequential re-hash pass over the arena, log-many
+/// times) — and for the profiling virtual spans.
+struct SegU64s {
   segs: Vec<HugeVec<u64>>,
   entries: usize,
 }
 
-impl SegHashes {
+impl SegU64s {
   fn new() -> Self {
     Self { segs: Vec::new(), entries: 0 }
   }
@@ -224,6 +225,11 @@ impl SegHashes {
     self.segs[seg].extend_from_slice(&[h]);
     self.entries += 1;
   }
+
+  #[inline]
+  fn set(&mut self, i: usize, v: u64) {
+    self.segs[i >> SEG_BITS].slice_mut(i & SEG_MASK, 1)[0] = v;
+  }
 }
 
 /// Append-only query store with a hash index.
@@ -247,25 +253,47 @@ pub struct QueryMap {
   /// Output width; inferred on first insert (not statically available in
   /// `FunctionLayout`).
   out_stride_set: bool,
+  /// Committed-trace width of this circuit (0 for unconstrained
+  /// functions): the per-touch price charged to the virtual-gas meter
+  /// (`QueryRecord::virt`).
+  weight: u64,
+  /// Whether `finish` records per-entry virtual spans (`vspans`).
+  /// Plumbed from the execution entrypoint's `profile` flag; off by
+  /// default so the extra u64 arena costs nothing on ordinary runs.
+  profile: bool,
   keys: SegStore,
   outs: SegStore,
   mults: SegStore,
-  hashes: SegHashes,
+  hashes: SegU64s,
+  /// Per-entry virtual-gas span recorded at the entry's (first
+  /// constrained) computation — the entry's standalone cost, replayed on
+  /// memo hits so `virt` prices the execution as if nothing were
+  /// memoized. Populated only by `finish` (function maps) and only when
+  /// `profile` is set; memory maps leave it empty and replay `weight`.
+  vspans: SegU64s,
   table: hashbrown::HashTable<u32>,
 }
 
 impl QueryMap {
-  pub fn new(key_stride: usize) -> Self {
+  pub fn new(key_stride: usize, weight: u64, profile: bool) -> Self {
     Self {
       out_stride_set: false,
+      weight,
+      profile,
       keys: SegStore::new(key_stride),
       outs: SegStore::new(0),
       mults: SegStore::new(1),
-      hashes: SegHashes::new(),
+      hashes: SegU64s::new(),
+      vspans: SegU64s::new(),
       table: hashbrown::HashTable::new(),
     }
   }
 
+  #[inline]
+  pub fn weight(&self) -> u64 {
+    self.weight
+  }
+
   #[inline]
   pub fn len(&self) -> usize {
     self.mults.entries
@@ -307,6 +335,67 @@ impl QueryMap {
     })
   }
 
+  /// Multiplicity of entry `i`.
+  #[inline]
+  pub fn mult_at(&self, i: usize) -> G {
+    self.mults.at(i)[0]
+  }
+
+  /// Output slice of entry `i`.
+  #[inline]
+  pub fn output_at(&self, i: usize) -> &[G] {
+    self.outs.at(i)
+  }
+
+  /// Constrained memo hit on entry `i`: bump the multiplicity and return
+  /// the replay cost to add to `QueryRecord::virt` — the entry's recorded
+  /// virtual span when one exists (function maps under `profile`), else
+  /// the map weight (memory maps, or profiling off).
+  #[inline]
+  pub fn replay_at(&mut self, i: usize) -> u64 {
+    self.mults.at_mut(i)[0] += G::ONE;
+    if i < self.vspans.entries { self.vspans.at(i) } else { self.weight }
+  }
+
+  /// Register a function query at `Ctrl::Return`: insert on first
+  /// registration, bump + re-span on constrained promotion of a cached
+  /// hint row. `span` is the virtual-gas span measured over the frame
+  /// (own-row touch included); recorded only when profiling. Function
+  /// maps must insert exclusively through here so `vspans` stays aligned
+  /// with the entry arenas.
+  pub fn finish(
+    &mut self,
+    key: &[G],
+    output: &[G],
+    constrained: bool,
+    span: u64,
+  ) {
+    if let Some(i) = self.get_index_of(key) {
+      // The only ordinary way to execute an already cached function is
+      // constrained promotion of an unconstrained hint entry.
+      debug_assert_eq!(self.outs.at(i), output);
+      if constrained {
+        self.mults.at_mut(i)[0] += G::ONE;
+        if self.profile {
+          // Overwrite the hint-time span (measured unconstrained, ~0)
+          // with the span of the constrained replay.
+          self.vspans.set(i, span);
+        }
+      }
+    } else {
+      self.insert(key, output, G::from_bool(constrained));
+      if self.profile {
+        self.vspans.push(span);
+      }
+    }
+  }
+
+  /// Recorded virtual span of entry `i` (0 when profiling is off).
+  #[inline]
+  pub fn vspan_at(&self, i: usize) -> u64 {
+    if i < self.vspans.entries { self.vspans.at(i) } else { 0 }
+  }
+
   /// Append a new entry. The key must not already be present: call sites
   /// only insert on a confirmed miss, and a same-key re-entrant call
   /// would loop forever before reaching its own insert.
diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs
index 552743c28..c78ecc1cf 100644
--- a/crates/aiur/src/synthesis.rs
+++ b/crates/aiur/src/synthesis.rs
@@ -1,6 +1,6 @@
 use multi_stark::{
   expr::Expr,
-  lookup::Lookup,
+  lookup::{Lookup, WidthBinding},
   p3_field::PrimeCharacteristicRing,
   p3_matrix::dense::RowMajorMatrix,
   prover::Proof,
@@ -38,6 +38,38 @@ pub struct PeakProveBytes {
   pub peak: usize,
 }
 
+// The allocation-schedule model below is deliberately structural, but the
+// process RSS also contains allocator/runtime residency that it does not name.
+// Across the 168 completed Mathlib shard proofs at multi-stark 2892243e,
+// measured RSS / analytic peak had median 1.0678 and maximum under-prediction
+// 1.0714. A 7.5% envelope covers the full sample with a small margin.
+const PROVER_RSS_CALIBRATION_NUMERATOR: usize = 43;
+const PROVER_RSS_CALIBRATION_DENOMINATOR: usize = 40;
+
+fn calibrate_prover_rss(analytic_peak: usize) -> usize {
+  analytic_peak
+    .checked_mul(PROVER_RSS_CALIBRATION_NUMERATOR)
+    .map_or(usize::MAX, |scaled| {
+      scaled.div_ceil(PROVER_RSS_CALIBRATION_DENOMINATOR)
+    })
+}
+
+/// Outcome of a budget-gated prove
+/// ([`AiurSystem::prove_ixvm_within_budget`]). Only the case that ran a
+/// STARK carries a proof; the other two report the measured peak the
+/// caller decides with.
+// One short-lived value per prove; the variant size gap is irrelevant.
+#[allow(clippy::large_enum_variant)]
+pub enum GatedProve {
+  /// Fit the budget; proven from the gating record.
+  Proved { claim: Vec<G>, proof: AiurProof, peak: usize },
+  /// Over budget: the record was dropped, and `parts` is the count
+  /// [`AiurSystem::suggested_split_parts`] projects will fit.
+  Split { peak: usize, parts: usize },
+  /// `exec_only` with a fitting peak: measured, nothing left to do.
+  Measured { peak: usize },
+}
+
 pub struct AiurSystem {
   toplevel: Toplevel,
   // perhaps remove the key from the system in verifier only mode?
@@ -73,6 +105,27 @@ pub struct CircuitShape {
   pub preprocessed_height: usize,
 }
 
+/// Raw row count of a circuit under `record`, ceil-divided into `parts`
+/// even shares — `parts = 1` is the record's exact heights. The byte
+/// gadgets keep their fixed heights: they are the same size in every
+/// shard and are most of the peak model's floor, which dividing cannot
+/// shrink.
+fn raw_of(
+  record: &QueryRecord,
+  parts: usize,
+) -> impl Fn(usize, &CircuitType) -> usize + '_ {
+  move |_, ct| match ct {
+    CircuitType::Function { idx } => {
+      record.function_queries[*idx].len().div_ceil(parts)
+    },
+    CircuitType::Memory { width } => {
+      record.memory_queries.get(width).map_or(0, |m| m.len().div_ceil(parts))
+    },
+    CircuitType::Bytes1 => 256,
+    CircuitType::Bytes2 => 65536,
+  }
+}
+
 impl AiurSystem {
   pub fn build(
     toplevel: Toplevel,
@@ -149,7 +202,11 @@ impl AiurSystem {
       2,
     );
 
-    let config = AiurConfig::new(commitment_parameters, fri_parameters);
+    // Aiur guarantees prefix-free messages by construction (see the channel
+    // constants in `lib.rs`), which is what licenses branch-shared lookup
+    // slots superposing messages of different natural widths.
+    let config = AiurConfig::new(commitment_parameters, fri_parameters)
+      .with_width_binding(WidthBinding::ByConstruction);
     let (system, key) = System::new(config, circuit_inputs);
     AiurSystem {
       system,
@@ -208,10 +265,9 @@ impl AiurSystem {
   /// Predicted peak prover resident bytes for a record, from circuit
   /// shapes alone — the analytic counterpart of an empirical GiB-per-fft
   /// line. Mirrors this system's actual allocation schedule (multi-stark
-  /// rev `be1755e`, the workspace pin; an upstream allocation-schedule
+  /// rev `2892243e`, the workspace pin; an upstream allocation-schedule
   /// change skews every prediction, so re-validate against a measured
-  /// prove when bumping multi-stark — real proves at ~472 GiB measured
-  /// +1.6-1.7% over prediction):
+  /// prove when bumping multi-stark):
   ///
   /// 1. WITNESS phase: the `QueryRecord` plus every circuit's padded main
   ///    trace and base-field lookup witness, built in parallel and all
@@ -224,20 +280,15 @@ impl AiurSystem {
   ///    retained FRI fold layers (geometric in `max_log_arity`), and the
   ///    open-phase buffers — all proportional to `H = blowup · tallest`.
   ///
-  /// The peak is the max of the three plus the preprocessed-gadget
-  /// residency committed at setup. Heights are `next_power_of_two` of the
+  /// The analytic peak is the max of the three plus the
+  /// preprocessed-gadget residency committed at setup. The returned `peak`
+  /// additionally applies [`calibrate_prover_rss`] to cover measured
+  /// allocator/runtime residency. Heights are `next_power_of_two` of the
   /// record's unique queries — the padding the trace actually commits,
   /// which per-fft models blur.
   pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes {
     self.peak_prove_bytes_by(
-      |_, ct| match ct {
-        CircuitType::Function { idx } => record.function_queries[*idx].len(),
-        CircuitType::Memory { width } => {
-          record.memory_queries.get(width).map_or(0, |m| m.len())
-        },
-        CircuitType::Bytes1 => 256,
-        CircuitType::Bytes2 => 65536,
-      },
+      raw_of(record, 1),
       crate::execute::record_retained_bytes(record),
     )
   }
@@ -293,35 +344,120 @@ impl AiurSystem {
     // Trees (3 rounds) + retained FRI fold layers + open buffers, all ∝ H.
     let fri_layers = (2 * S + 2 * DG) * h * fold / (fold - 1).max(1);
     let phase_open = committed + 3 * 2 * DG * h + fri_layers + 11 * S * h;
+    let analytic_peak = phase_witness.max(phase_stage2).max(phase_open) + prep;
     PeakProveBytes {
       phase_witness,
       phase_stage2,
       phase_open,
       preprocessed: prep,
-      peak: phase_witness.max(phase_stage2).max(phase_open) + prep,
+      peak: calibrate_prover_rss(analytic_peak),
     }
   }
 
-  #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")]
-  pub fn prove(
+  /// Per-circuit raw heights of `record` in system order, with the
+  /// record's retained bytes as the trailing element — the composable
+  /// measurement the shard-planning group bound sums: per-circuit
+  /// unions are bounded by elementwise sums, so summed vectors feed
+  /// [`Self::peak_of_raws`] as a sound upper bound on a merged shard.
+  pub fn raw_heights(&self, record: &QueryRecord) -> Vec<u64> {
+    let f = raw_of(record, 1);
+    let mut v: Vec<u64> = self
+      .circuit_types()
+      .iter()
+      .enumerate()
+      .map(|(i, ct)| f(i, ct) as u64)
+      .collect();
+    v.push(crate::execute::record_retained_bytes(record) as u64);
+    v
+  }
+
+  /// Evaluate the peak model on a raw-height vector from
+  /// [`Self::raw_heights`] — possibly an elementwise SUM of several
+  /// segments' vectors, in which case the result is an upper bound on
+  /// the merged shard's peak. Gadget circuits are re-fixed to their
+  /// constant heights internally, so dumb elementwise summation stays
+  /// valid. `None` on a length mismatch or a value beyond `usize`.
+  pub fn peak_of_raws(&self, raws: &[u64]) -> Option<usize> {
+    let ncirc = self.system.circuits.len();
+    if raws.len() != ncirc + 1 {
+      return None;
+    }
+    let raws: Vec<usize> =
+      raws.iter().map(|&r| usize::try_from(r).ok()).collect::<Option<_>>()?;
+    let peak = self
+      .peak_prove_bytes_by(
+        |i, ct| match ct {
+          CircuitType::Bytes1 => 256,
+          CircuitType::Bytes2 => 65536,
+          _ => raws[i],
+        },
+        raws[ncirc],
+      )
+      .peak;
+    Some(peak)
+  }
+
+  /// Smallest power-of-two part count whose projected per-part peak
+  /// fits `max_bytes`, assuming the record's rows divide evenly across
+  /// parts. The gadget circuits keep their constant heights — they are
+  /// the same size in every shard and are most of the model's fixed
+  /// floor, which dividing cannot shrink.
+  ///
+  /// The estimate is optimistic: a part re-executes dependencies shared
+  /// across the cut, so its real rows exceed its 1/n share. A caller
+  /// splitting on this number must still gate each part on its own
+  /// executed record and re-split the ones that miss. Optimism is the
+  /// right bias — an under-split costs one cheap re-execution, while an
+  /// over-split pays the per-proof floor on every extra part forever.
+  ///
+  /// Returns 1 when the record already fits.
+  pub fn suggested_split_parts(
+    &self,
+    record: &QueryRecord,
+    max_bytes: usize,
+  ) -> usize {
+    let record_bytes = crate::execute::record_retained_bytes(record);
+    let mut parts = 1usize;
+    // A shard still over budget at 2^20 parts is not splittable by row
+    // count; stop rather than search forever.
+    while parts < (1 << 20) {
+      let peak = self
+        .peak_prove_bytes_by(raw_of(record, parts), record_bytes / parts)
+        .peak;
+      if peak <= max_bytes {
+        break;
+      }
+      parts *= 2;
+    }
+    parts
+  }
+
+  /// Prove an execution that has ALREADY happened: everything from the
+  /// witness phase on, over a record the caller hands across.
+  ///
+  /// Taking `query_record` by value is the point. The record is the
+  /// witness phase's dominant residency, and it is dropped here the
+  /// instant the traces exist — before the LDE/commit/FRI phases that
+  /// actually set the prover's peak (see [`Self::peak_prove_bytes`]).
+  /// A caller that keeps its own copy alive past this call pays that
+  /// peak *on top of* the record, which at shard scale is the
+  /// difference between fitting in RAM and not.
+  ///
+  /// `input`, `io_buffer` and `output` must be the ones the execution
+  /// ran on: they reconstruct the claim the proof commits to, and the
+  /// witness reads the buffer the execution left behind.
+  ///
+  /// Deliberately not `#[tracing::instrument]`ed — the `aiur/witness`
+  /// span below stays directly under the caller's `aiur/prove*` span,
+  /// so the stage-scoped measurements keep their existing shape.
+  pub fn prove_from_execution(
     &self,
     fun_idx: FunIdx,
     input: &[G],
-    io_buffer: &mut IOBuffer,
+    io_buffer: &IOBuffer,
+    query_record: QueryRecord,
+    output: &[G],
   ) -> (Vec<G>, AiurProof) {
-    tracing_texray::examine_current();
-
-    // Execute the Aiur bytecode.
-    let _g = tracing::info_span!("aiur/execute").entered();
-    // Execute the Aiur bytecode. The prover assumes inputs are valid; any
-    // execution error here is a programmer bug, so we unwrap.
-    let (query_record, output) = self
-      .toplevel
-      .execute(fun_idx, input.to_vec(), io_buffer)
-      .expect("Aiur execution failed during prove");
-    drop(_g);
-
-    // Build the `SystemWitness`
     let _g = tracing::info_span!("aiur/witness").entered();
     let circuit_types = self.circuit_types();
     let witness_data = circuit_types
@@ -363,6 +499,28 @@ impl AiurSystem {
     (claim, proof)
   }
 
+  #[tracing::instrument(level = "info", skip_all, name = "aiur/prove")]
+  pub fn prove(
+    &self,
+    fun_idx: FunIdx,
+    input: &[G],
+    io_buffer: &mut IOBuffer,
+  ) -> (Vec<G>, AiurProof) {
+    tracing_texray::examine_current();
+
+    // Execute the Aiur bytecode.
+    let _g = tracing::info_span!("aiur/execute").entered();
+    // Execute the Aiur bytecode. The prover assumes inputs are valid; any
+    // execution error here is a programmer bug, so we unwrap.
+    let (query_record, output) = self
+      .toplevel
+      .execute(fun_idx, input.to_vec(), io_buffer, false)
+      .expect("Aiur execution failed during prove");
+    drop(_g);
+
+    self.prove_from_execution(fun_idx, input, io_buffer, query_record, &output)
+  }
+
   /// IxVM-native prove: identical to `prove` except the execute step
   /// is provided by the caller as `executor` (a closure that runs
   /// the codegen'd Rust kernel `ix::aiur_ixvm_runner::execute_ixvm`
@@ -381,6 +539,51 @@ impl AiurSystem {
     io_buffer: &mut IOBuffer,
     executor: F,
   ) -> (Vec<G>, AiurProof)
+  where
+    F: FnOnce(
+      &Toplevel,
+      FunIdx,
+      Vec<G>,
+      &mut IOBuffer,
+    ) -> Result<(QueryRecord, Vec<G>), ExecError>,
+  {
+    match self.prove_ixvm_within_budget(
+      fun_idx, input, io_buffer, executor, None, false,
+    ) {
+      GatedProve::Proved { claim, proof, .. } => (claim, proof),
+      _ => unreachable!("an unbudgeted prove always proves"),
+    }
+  }
+
+  /// `prove_ixvm`, but the record's projected prover peak has to fit
+  /// `max_bytes` before any proving starts (`None` skips the check),
+  /// and `exec_only` stops after execution + measurement — the split
+  /// loop runs on executions alone, no STARK started.
+  ///
+  /// The peak is measured on the REAL record ([`Self::peak_prove_bytes`]),
+  /// not estimated from serialized bytes, so an over-budget shard is
+  /// caught in the gap between execution and the witness phase — before
+  /// the LDE/commit/FRI phases that would actually exhaust the box: the
+  /// record is dropped and [`GatedProve::Split`] carries the part count
+  /// [`Self::suggested_split_parts`] projects will fit, computed here
+  /// because this is the last moment the record exists to read counts
+  /// from. Every outcome carries the measured peak: proving a shard
+  /// measures it for free, so a prove run yields the same split/merge
+  /// signal a check run does without a second execution.
+  #[tracing::instrument(
+    level = "info",
+    skip_all,
+    name = "aiur/prove_ixvm_within_budget"
+  )]
+  pub fn prove_ixvm_within_budget<F>(
+    &self,
+    fun_idx: FunIdx,
+    input: &[G],
+    io_buffer: &mut IOBuffer,
+    executor: F,
+    max_bytes: Option<usize>,
+    exec_only: bool,
+  ) -> GatedProve
   where
     F: FnOnce(
       &Toplevel,
@@ -396,43 +599,24 @@ impl AiurSystem {
         .expect("IxVM-native Aiur execution failed during prove_ixvm");
     drop(_g);
 
-    let _g = tracing::info_span!("aiur/witness").entered();
-    let circuit_types = self.circuit_types();
-    let witness_data = circuit_types
-      .into_par_iter()
-      .enumerate()
-      .map(|(circuit_idx, circuit_type)| {
-        let slot_arg_widths = self.slot_arg_widths(circuit_idx);
-        match circuit_type {
-          CircuitType::Function { idx } => self.toplevel.witness_data(
-            idx,
-            &query_record,
-            io_buffer,
-            &slot_arg_widths,
-          ),
-          CircuitType::Memory { width } => {
-            Memory::witness_data(width, &query_record, &slot_arg_widths)
-          },
-          CircuitType::Bytes1 => {
-            Bytes1.witness_data(&query_record, &slot_arg_widths)
-          },
-          CircuitType::Bytes2 => {
-            Bytes2.witness_data(&query_record, &slot_arg_widths)
-          },
-        }
-      })
-      .collect::<Vec<_>>();
-    drop(query_record);
-    let (traces, lookups) = witness_data.into_iter().unzip();
-    let witness = SystemWitness { traces, lookups };
-    drop(_g);
-
-    let mut claim = vec![function_channel(), G::from_usize(fun_idx)];
-    claim.extend(input);
-    claim.extend(output);
-
-    let proof = self.system.prove(&self.key, &claim, witness);
-    (claim, proof)
+    let peak = self.peak_prove_bytes(&query_record).peak;
+    if let Some(max) = max_bytes
+      && peak > max
+    {
+      let parts = self.suggested_split_parts(&query_record, max);
+      return GatedProve::Split { peak, parts };
+    }
+    if exec_only {
+      return GatedProve::Measured { peak };
+    }
+    let (claim, proof) = self.prove_from_execution(
+      fun_idx,
+      input,
+      io_buffer,
+      query_record,
+      &output,
+    );
+    GatedProve::Proved { claim, proof, peak }
   }
 
   #[inline]
@@ -443,6 +627,19 @@ impl AiurSystem {
   ) -> Result<(), VerificationError<PcsError>> {
     self.system.verify(claim, proof)
   }
+
+  /// Verify and serialize the native Plonky3 multiproof for the in-circuit
+  /// recursive verifier.
+  pub fn proof_to_advice_bytes(
+    &self,
+    claim: &[G],
+    proof: &AiurProof,
+  ) -> Result<Vec<u8>, multi_stark::advice::AdviceError> {
+    self.verify(claim, proof).map_err(|e| {
+      multi_stark::advice::AdviceError::Verification(format!("{e:?}"))
+    })?;
+    proof.to_bytes().map_err(multi_stark::advice::AdviceError::Encode)
+  }
 }
 
 #[cfg(test)]
@@ -458,6 +655,13 @@ mod tests {
   };
   use rustc_hash::FxHashMap;
 
+  #[test]
+  fn prover_rss_calibration_rounds_up_and_saturates() {
+    assert_eq!(calibrate_prover_rss(40), 43);
+    assert_eq!(calibrate_prover_rss(1_000), 1_075);
+    assert_eq!(calibrate_prover_rss(usize::MAX), usize::MAX);
+  }
+
   /// Small FRI parameters mirroring `vk_codec`'s test config: cheap to prove
   /// while still exercising the full FRI pipeline (log_blowup 1, 64 queries,
   /// no proof-of-work).
@@ -814,4 +1018,82 @@ mod tests {
     assert_eq!(shapes[4].preprocessed_width, 14);
     assert_eq!(shapes[4].preprocessed_height, 65536);
   }
+
+  /// Two match branches whose calls target functions of different arity, so
+  /// they share one lookup slot with mismatched message widths.
+  ///
+  /// - `f0(x)`: matches on `x`; branch `0` calls `f1(x)` (message width 4),
+  ///   branch `1` calls `f2(x, x)` (message width 5).
+  /// - Both calls land in lookup slot 1, whose width is the max (5), so the
+  ///   `f1` message is sent zero-padded to 5 while `f1`'s own return slot
+  ///   provides it at width 4.
+  ///
+  /// Zero-padding transparency is what makes the padded send match the
+  /// natural-width provider — the `WidthBinding::ByConstruction`
+  /// declaration in `AiurSystem::build`. Under width-bound fingerprints
+  /// this shape fails to verify with `UnbalancedChannel`.
+  fn mismatched_call_widths_toplevel() -> Toplevel {
+    let branch_narrow = Block {
+      ops: vec![Op::Call(1, vec![0], 1, false)],
+      ctrl: Ctrl::Return(0, vec![1]),
+    };
+    let branch_wide = Block {
+      ops: vec![Op::Call(2, vec![0, 0], 1, false)],
+      ctrl: Ctrl::Return(1, vec![1]),
+    };
+    let cases: crate::FxIndexMap<G, Block> =
+      [(G::ZERO, branch_narrow), (G::ONE, branch_wide)].into_iter().collect();
+    let f0 = Function {
+      body: Block { ops: vec![], ctrl: Ctrl::Match(0, cases, None) },
+      layout: FunctionLayout {
+        input_size: 1,
+        selectors: 2,
+        auxiliaries: 2,
+        lookups: 2,
+      },
+      entry: true,
+      constrained: true,
+    };
+    // f1(a) = a
+    let f1 = Function {
+      body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) },
+      layout: FunctionLayout {
+        input_size: 1,
+        selectors: 1,
+        auxiliaries: 1,
+        lookups: 1,
+      },
+      entry: false,
+      constrained: true,
+    };
+    // f2(a, b) = a
+    let f2 = Function {
+      body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) },
+      layout: FunctionLayout {
+        input_size: 2,
+        selectors: 1,
+        auxiliaries: 1,
+        lookups: 1,
+      },
+      entry: false,
+      constrained: true,
+    };
+    Toplevel { functions: vec![f0, f1, f2], memory_sizes: vec![] }
+  }
+
+  #[test]
+  fn prove_verify_mismatched_call_widths() {
+    let (cp, fp) = test_parameters();
+    let system = AiurSystem::build(mismatched_call_widths_toplevel(), cp, fp);
+
+    // Branch 0: the narrow call, whose slot is padded to the wide width.
+    let mut io_buffer = empty_io_buffer();
+    let (claim, proof) = system.prove(0, &[G::ZERO], &mut io_buffer);
+    system.verify(&claim, &proof).expect("narrow-branch proof must verify");
+
+    // Branch 1: the wide call, whose width already matches its slot.
+    let mut io_buffer = empty_io_buffer();
+    let (claim, proof) = system.prove(0, &[G::ONE], &mut io_buffer);
+    system.verify(&claim, &proof).expect("wide-branch proof must verify");
+  }
 }
diff --git a/crates/aiur/src/vk_codec.rs b/crates/aiur/src/vk_codec.rs
index 9fa9e00ec..e19baf198 100644
--- a/crates/aiur/src/vk_codec.rs
+++ b/crates/aiur/src/vk_codec.rs
@@ -45,6 +45,7 @@
 //!   u32 zero_count, then zero_count x u16 LE constraint-root node ids
 //!   u32 lookup_count, then per lookup:
 //!     u16 LE multiplicity node id
+//!     u64 LE max_multiplicity (declared per-row multiplicity bound)
 //!     u16 LE arg count, then arg_count x u16 LE arg node ids
 //! TRAILER
 //!   u8           preprocessed commit flag (0 = None / 1 = Some)
@@ -64,7 +65,7 @@
 use multi_stark::{
   expr::{ColRef, RowOffset, Source},
   graph::{ConstraintGraph, Node, NodeId},
-  lookup::Lookup,
+  lookup::{Lookup, WidthBinding},
   p3_field::{PrimeCharacteristicRing, PrimeField64},
   system::{Circuit, System},
   types::{Commitment, CommitmentParameters, FriParameters, Val},
@@ -89,6 +90,10 @@ fn push_u32(buf: &mut Vec<u8>, v: usize) {
   buf.extend_from_slice(&v.to_le_bytes());
 }
 
+fn push_u64(buf: &mut Vec<u8>, v: u64) {
+  buf.extend_from_slice(&v.to_le_bytes());
+}
+
 /// Node ids on the wire are u16: per-circuit graphs are far below 65k
 /// nodes (the whole kernel system is ~140k across 800+ circuits).
 fn push_node_id(buf: &mut Vec<u8>, id: NodeId) {
@@ -185,6 +190,7 @@ fn encode_circuit(buf: &mut Vec<u8>, circuit: &Circuit<Val>) {
   push_u16(buf, compiled.lookups.len());
   for lookup in &compiled.lookups {
     push_node_id(buf, lookup.multiplicity);
+    push_u64(buf, lookup.max_multiplicity);
     push_u16(buf, lookup.args.len());
     for &arg in &lookup.args {
       push_node_id(buf, arg);
@@ -361,12 +367,13 @@ fn decode_circuit(seg: &mut Seg<'_>) -> Result<Circuit<Val>, String> {
   let mut lookups = Vec::with_capacity(lookup_count);
   for _ in 0..lookup_count {
     let multiplicity = seg.node_id()?;
+    let max_multiplicity = seg.u64()?;
     let arg_count = seg.u16()? as usize;
     let mut args = Vec::with_capacity(arg_count.min(1 << 16));
     for _ in 0..arg_count {
       args.push(seg.node_id()?);
     }
-    lookups.push(Lookup { multiplicity, args });
+    lookups.push(Lookup { multiplicity, args, max_multiplicity });
   }
 
   let degrees = recompute_degrees(&nodes);
@@ -483,7 +490,11 @@ pub(crate) fn from_bytes(
   }
   r.done("vk")?;
   let system = System {
-    config: AiurConfig::new(commitment_parameters, fri_parameters),
+    // Aiur systems are always built with `ByConstruction` width binding
+    // (see `AiurSystem::build`), so the decoder must rebuild the config
+    // identically for the verifier's transcript to match.
+    config: AiurConfig::new(commitment_parameters, fri_parameters)
+      .with_width_binding(WidthBinding::ByConstruction),
     circuits,
     preprocessed_commit,
     preprocessed_indices,
@@ -532,7 +543,10 @@ mod tests {
         lookup_group_size: 2,
       },
     ];
-    let (system, _key) = System::new(AiurConfig::new(cp, fp), inputs);
+    let (system, _key) = System::new(
+      AiurConfig::new(cp, fp).with_width_binding(WidthBinding::ByConstruction),
+      inputs,
+    );
     (system, cp, fp)
   }
 
diff --git a/crates/common/src/address.rs b/crates/common/src/address.rs
index 334aafd13..0bc032456 100644
--- a/crates/common/src/address.rs
+++ b/crates/common/src/address.rs
@@ -46,10 +46,12 @@ impl Address {
   }
 
   /// Iterate addresses out of a flat `[u8; 32 * N]` byte blob. Trailing
-  /// bytes shorter than 32 are silently dropped (via `chunks_exact`).
+  /// bytes shorter than 32 are silently dropped.
   pub fn unpack(bytes: &[u8]) -> impl Iterator<Item = Address> + '_ {
     bytes
-      .chunks_exact(32)
+      .as_chunks::<32>()
+      .0
+      .iter()
       .map(|c| Address::from_slice(c).expect("malformed address chunk"))
   }
 
diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs
index 902f5756e..a2b6eb5b0 100644
--- a/crates/compile/src/compile.rs
+++ b/crates/compile/src/compile.rs
@@ -1209,7 +1209,7 @@ pub fn compile_expr(
                       });
                     }
                     let n_specs = specs.len();
-                    canonical_args.extend(specs.into_iter());
+                    canonical_args.extend(specs);
                     for (src_i, motive) in motives.iter().enumerate() {
                       if plan.motive_keep[src_i] {
                         canonical_args.push(motive.clone());
diff --git a/crates/compile/src/compile/aux_gen/brecon.rs b/crates/compile/src/compile/aux_gen/brecon.rs
index ee9134edb..da2db5172 100644
--- a/crates/compile/src/compile/aux_gen/brecon.rs
+++ b/crates/compile/src/compile/aux_gen/brecon.rs
@@ -510,8 +510,7 @@ fn build_prop_below_minor_fvar(
   let mut lambda_fvars: Vec<LeanExpr> = Vec::new();
   let mut ctor_args: Vec<LeanExpr> = Vec::new();
 
-  for (fi, (decl, fvar)) in
-    field_decls.into_iter().zip(field_fvars.into_iter()).enumerate()
+  for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate()
   {
     if let Some(j_prime) = find_motive_fvar(&decl.domain, motive_fvars) {
       // IH field. For a non-reflexive IH `motive args`, the new binder is
@@ -1134,8 +1133,7 @@ fn build_type_minor_premise_fvar(
   let mut lambda_fvars: Vec<LeanExpr> = Vec::new();
   let mut prod_entries: Vec<(LeanExpr, usize)> = Vec::new(); // (fvar, lambda_index) for IH fields
 
-  for (fi, (decl, fvar)) in
-    field_decls.into_iter().zip(field_fvars.into_iter()).enumerate()
+  for (fi, (decl, fvar)) in field_decls.into_iter().zip(field_fvars).enumerate()
   {
     if let Some(_j_prime) = find_motive_fvar(&decl.domain, motive_fvars) {
       // IH field: replace domain with PProd(motive, below)
diff --git a/crates/compile/src/compile/aux_gen/cases_on.rs b/crates/compile/src/compile/aux_gen/cases_on.rs
index bad60eee0..096891920 100644
--- a/crates/compile/src/compile/aux_gen/cases_on.rs
+++ b/crates/compile/src/compile/aux_gen/cases_on.rs
@@ -191,7 +191,7 @@ pub fn generate_cases_on(
       let mut non_ih_fvars: Vec<LeanExpr> = Vec::new();
       let mut wrapper_decls: Vec<LocalDecl> = Vec::new(); // all fields for the rec lambda
 
-      for (decl, fvar) in field_decls.into_iter().zip(field_fvars.into_iter()) {
+      for (decl, fvar) in field_decls.into_iter().zip(field_fvars) {
         let motive_idx = find_motive_fvar(&decl.domain, &motive_fvars);
         if let Some(idx) = motive_idx {
           if idx == target_idx {
diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs
index 2f4afa9f3..b30545b82 100644
--- a/crates/compile/src/compile/env.rs
+++ b/crates/compile/src/compile/env.rs
@@ -397,7 +397,7 @@ pub fn compile_env_with_options(
   // Use scoped threads to borrow from parent scope. `IX_COMPILE_WORKERS`
   // gives large-env callers a simple peak-memory/speed tradeoff knob.
   let available_threads =
-    thread::available_parallelism().map(|n| n.get()).unwrap_or(4);
+    thread::available_parallelism().map_or(4, |n| n.get());
   let requested_threads = options.max_workers.or_else(|| {
     std::env::var("IX_COMPILE_WORKERS")
       .ok()
diff --git a/crates/compile/src/compile/mutual.rs b/crates/compile/src/compile/mutual.rs
index 17a67882a..e62050590 100644
--- a/crates/compile/src/compile/mutual.rs
+++ b/crates/compile/src/compile/mutual.rs
@@ -712,8 +712,8 @@ pub fn generate_and_compile_aux_recursors(
   // `populate_recursor_rules_from_block` comment in the kernel.
   let t1 = std::time::Instant::now();
   let rec_consts: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::Rec(r) => Some(MutConst::Recr(r.clone())),
       _ => None,
     })
@@ -822,8 +822,8 @@ pub fn generate_and_compile_aux_recursors(
   // (because .brecOn.eq references casesOn).
   let t2 = std::time::Instant::now();
   let cases_on_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::CasesOn(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -846,8 +846,8 @@ pub fn generate_and_compile_aux_recursors(
   // recOn wraps .rec and must be compiled after .rec.
   let t3 = std::time::Instant::now();
   let rec_on_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::RecOn(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -887,8 +887,8 @@ pub fn generate_and_compile_aux_recursors(
   // order with the canonical `all`.
   let t4 = std::time::Instant::now();
   let mut below_raw: Vec<&BelowIndc> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::BelowIndc(bi) => Some(bi),
       _ => None,
     })
@@ -932,8 +932,8 @@ pub fn generate_and_compile_aux_recursors(
 
   // Phase 4: Compile .below definitions (Type-level).
   let below_defs: Vec<MutConst> = patches
-    .iter()
-    .filter_map(|(_, p)| match p {
+    .values()
+    .filter_map(|p| match p {
       PatchedConstant::BelowDef(d) => Some(MutConst::Defn(Def {
         name: d.name.clone(),
         level_params: d.level_params.clone(),
@@ -970,8 +970,8 @@ pub fn generate_and_compile_aux_recursors(
   let t6 = std::time::Instant::now();
   for batch in 0..3u8 {
     let defs: Vec<MutConst> = patches
-      .iter()
-      .filter_map(|(_, p)| match p {
+      .values()
+      .filter_map(|p| match p {
         PatchedConstant::BRecOn(d) if brecon_batch(&d.name) == batch => {
           Some(brecon_to_mut_const(d))
         },
diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs
index 01ad45ace..543b5f5ea 100644
--- a/crates/ffi/src/aiur.rs
+++ b/crates/ffi/src/aiur.rs
@@ -1,5 +1,6 @@
 use multi_stark::p3_field::integers::QuotientMap;
 
+pub mod aggregate;
 pub mod protocol;
 pub mod toplevel;
 
diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs
new file mode 100644
index 000000000..1406af97a
--- /dev/null
+++ b/crates/ffi/src/aiur/aggregate.rs
@@ -0,0 +1,1811 @@
+//! Native Stage 2 orchestration for `ix aggregate`.
+//!
+//! Lean still constructs the two Aiur bytecode systems, because their source
+//! programs are Lean-authored. Everything data-dependent after that point is
+//! kept here: manifest/environment binding, shard-claim reconstruction,
+//! statement folding, cache validation, dependency scheduling, recursive
+//! advice construction, proving, and persistence.
+//!
+//! The host statements deliberately cache roots and sorted leaves. Structural
+//! subject trees carry only their two children and a small shard-membership
+//! bitset, so deciding whether an assumption is discharged is O(1), and a
+//! Merkle path is O(log n). This avoids the eager recursive `root`/`leaves`/
+//! `contains` traversals that made the former Lean startup super-linear.
+
+#![allow(clippy::too_many_arguments)]
+
+use std::{
+  cmp::Ordering,
+  fs,
+  path::{Path, PathBuf},
+  sync::{Arc, OnceLock, mpsc},
+  thread,
+  time::Instant,
+};
+
+use aiur::{
+  G, function_channel,
+  synthesis::{AiurProof, AiurSystem},
+};
+use ix_common::address::Address;
+use ix_kernel::shard::{AggNode, ShardManifest};
+use ixon::{
+  Claim, Constant, ConstantInfo, Proof as IxonProof,
+  assumption_tree::AssumptionTree,
+  merkle::{
+    MerklePath, leaf_hash, merkle_root_canonical_sorted, node_hash,
+    zero_address,
+  },
+  shard_claim::thin_frontier,
+};
+use ixvm_codegen::{
+  aiur_ix_aggr_runner::{
+    AggrAdvice, AggrPath, AggrPreimage, AggrTree, aggr_io_buffer,
+    execute_ix_aggr,
+  },
+  env_handle::EnvHandle,
+};
+use lean_ffi::object::{
+  LeanBorrowed, LeanByteArray, LeanExcept, LeanExternal, LeanNat, LeanOwned,
+  LeanString,
+};
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
+use rustc_hash::{FxHashMap, FxHashSet};
+
+use super::lean_unbox_nat_as_usize;
+
+const CACHE_VERSION: u64 = 2;
+const GIB: usize = 1024 * 1024 * 1024;
+const WRAP_RAM_BYTES: usize = 195 * GIB;
+const STRUCTURAL_RAM_BYTES: usize = 195 * GIB;
+const RAW_SHARD_RAM_BYTES: usize = 4 * GIB;
+const DIRECT_RAM_BYTES: usize = 390 * GIB;
+const MIXED_RAM_BYTES: usize = 340 * GIB;
+const FLAT_RAM_PER_SUBJECT: usize = 1024 * 1024;
+
+fn format_gib(bytes: usize) -> String {
+  let tenths = bytes.saturating_mul(10) / GIB;
+  format!("{}.{:01}", tenths / 10, tenths % 10)
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ChildKind {
+  Ixvm,
+  Aggr,
+}
+
+impl ChildKind {
+  const fn code(self) -> u8 {
+    match self {
+      Self::Ixvm => 0,
+      Self::Aggr => 1,
+    }
+  }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct ShardSet(Vec<u64>);
+
+impl ShardSet {
+  fn singleton(index: usize, shard_count: usize) -> Self {
+    let mut words = vec![0; shard_count.div_ceil(64)];
+    words[index / 64] |= 1u64 << (index % 64);
+    Self(words)
+  }
+
+  fn union(&self, other: &Self) -> Self {
+    debug_assert_eq!(self.0.len(), other.0.len());
+    Self(self.0.iter().zip(&other.0).map(|(a, b)| a | b).collect())
+  }
+
+  fn contains(&self, index: usize) -> bool {
+    self
+      .0
+      .get(index / 64)
+      .is_some_and(|word| word & (1u64 << (index % 64)) != 0)
+  }
+}
+
+/// Canonical sorted tree whose expensive derivative representations are built
+/// once, on demand. The root is computed once at construction.
+#[derive(Debug)]
+struct CanonicalTree {
+  leaves: Arc<[Address]>,
+  root: Address,
+  serialized: OnceLock<Vec<u8>>,
+  levels: OnceLock<Vec<Vec<Address>>>,
+}
+
+impl CanonicalTree {
+  fn from_sorted(leaves: Vec<Address>) -> Result<Option<Arc<Self>>, String> {
+    if leaves.is_empty() {
+      return Ok(None);
+    }
+    if !leaves.windows(2).all(|w| w[0] < w[1]) {
+      return Err("canonical tree leaves are not strictly sorted".into());
+    }
+    let root = merkle_root_canonical_sorted(&leaves)
+      .ok_or("nonempty canonical tree did not produce a root")?;
+    Ok(Some(Arc::new(Self {
+      leaves: leaves.into(),
+      root,
+      serialized: OnceLock::new(),
+      levels: OnceLock::new(),
+    })))
+  }
+
+  fn serialized(&self) -> &[u8] {
+    self.serialized.get_or_init(|| {
+      let tree = AssumptionTree::canonical(&self.leaves)
+        .expect("a nonempty canonical leaf list has a tree");
+      debug_assert_eq!(tree.root(), self.root);
+      tree.ser()
+    })
+  }
+
+  fn levels(&self) -> &[Vec<Address>] {
+    self.levels.get_or_init(|| {
+      let mut levels: Vec<Vec<Address>> =
+        vec![self.leaves.iter().map(leaf_hash).collect()];
+      let zero = zero_address();
+      while levels.last().is_some_and(|level| level.len() > 1) {
+        let previous = levels.last().expect("one level exists");
+        let mut next = Vec::with_capacity(previous.len().div_ceil(2));
+        for pair in previous.chunks(2) {
+          next.push(node_hash(&pair[0], pair.get(1).unwrap_or(&zero)));
+        }
+        levels.push(next);
+      }
+      levels
+    })
+  }
+
+  fn merkle_proof(&self, target: &Address) -> Option<MerklePath> {
+    let mut position = self.leaves.binary_search(target).ok()?;
+    let levels = self.levels();
+    let zero = zero_address();
+    let mut path = Vec::with_capacity(levels.len().saturating_sub(1));
+    for level in levels.iter().take(levels.len().saturating_sub(1)) {
+      let sibling =
+        level.get(position ^ 1).cloned().unwrap_or_else(|| zero.clone());
+      path.push((sibling, position & 1 == 1));
+      position /= 2;
+    }
+    Some(path)
+  }
+}
+
+#[derive(Debug)]
+enum SubjectRepr {
+  Canonical(Arc<CanonicalTree>),
+  Structural { left: Arc<SubjectTree>, right: Arc<SubjectTree> },
+}
+
+#[derive(Debug)]
+struct SubjectTree {
+  root: Address,
+  count: usize,
+  shards: ShardSet,
+  repr: SubjectRepr,
+}
+
+impl SubjectTree {
+  fn canonical(
+    leaves: Vec<Address>,
+    shards: ShardSet,
+  ) -> Result<Arc<Self>, String> {
+    let count = leaves.len();
+    let canonical = CanonicalTree::from_sorted(leaves)?
+      .ok_or("a shard cannot have an empty subject tree")?;
+    Ok(Arc::new(Self {
+      root: canonical.root.clone(),
+      count,
+      shards,
+      repr: SubjectRepr::Canonical(canonical),
+    }))
+  }
+
+  fn flat(left: &Arc<Self>, right: &Arc<Self>) -> Result<Arc<Self>, String> {
+    let SubjectRepr::Canonical(left_tree) = &left.repr else {
+      return Err("flat aggregate has a structural left child".into());
+    };
+    let SubjectRepr::Canonical(right_tree) = &right.repr else {
+      return Err("flat aggregate has a structural right child".into());
+    };
+    let leaves = merge_sorted(&left_tree.leaves, &right_tree.leaves);
+    if leaves.len() != left.count.saturating_add(right.count) {
+      return Err("aggregate subject sets overlap".into());
+    }
+    Self::canonical(leaves, left.shards.union(&right.shards))
+  }
+
+  fn structural(left: Arc<Self>, right: Arc<Self>) -> Arc<Self> {
+    Arc::new(Self {
+      root: node_hash(&left.root, &right.root),
+      count: left.count.saturating_add(right.count),
+      shards: left.shards.union(&right.shards),
+      repr: SubjectRepr::Structural { left, right },
+    })
+  }
+
+  fn canonical_tree(&self) -> Option<&CanonicalTree> {
+    match &self.repr {
+      SubjectRepr::Canonical(tree) => Some(tree),
+      SubjectRepr::Structural { .. } => None,
+    }
+  }
+
+  fn merkle_proof(&self, target: &Address, owner: usize) -> Option<MerklePath> {
+    if !self.shards.contains(owner) {
+      return None;
+    }
+    match &self.repr {
+      SubjectRepr::Canonical(tree) => tree.merkle_proof(target),
+      SubjectRepr::Structural { left, right } => {
+        if left.shards.contains(owner) {
+          let mut path = left.merkle_proof(target, owner)?;
+          path.push((right.root.clone(), false));
+          Some(path)
+        } else {
+          let mut path = right.merkle_proof(target, owner)?;
+          path.push((left.root.clone(), true));
+          Some(path)
+        }
+      },
+    }
+  }
+
+  fn collect_leaves(&self, out: &mut Vec<Address>) {
+    match &self.repr {
+      SubjectRepr::Canonical(tree) => out.extend_from_slice(&tree.leaves),
+      SubjectRepr::Structural { left, right } => {
+        left.collect_leaves(out);
+        right.collect_leaves(out);
+      },
+    }
+  }
+}
+
+#[derive(Debug)]
+struct Statement {
+  subjects: Arc<SubjectTree>,
+  assumptions: Option<Arc<CanonicalTree>>,
+  claim: Claim,
+  claim_bytes: Vec<u8>,
+}
+
+impl Statement {
+  fn new(
+    subjects: Arc<SubjectTree>,
+    assumptions: Option<Arc<CanonicalTree>>,
+  ) -> Arc<Self> {
+    let claim = Claim::CheckEnv {
+      root: subjects.root.clone(),
+      assumptions: assumptions.as_ref().map(|tree| tree.root.clone()),
+    };
+    let mut claim_bytes = Vec::new();
+    claim.put(&mut claim_bytes);
+    Arc::new(Self { subjects, assumptions, claim, claim_bytes })
+  }
+
+  fn join(
+    left: &Arc<Self>,
+    right: &Arc<Self>,
+    structural: bool,
+    owner_by_address: &FxHashMap<Address, usize>,
+  ) -> Result<Arc<Self>, String> {
+    let subjects = if structural {
+      SubjectTree::structural(left.subjects.clone(), right.subjects.clone())
+    } else {
+      SubjectTree::flat(&left.subjects, &right.subjects)?
+    };
+    let candidates = merge_optional_sets(
+      left.assumptions.as_deref(),
+      right.assumptions.as_deref(),
+    );
+    let mut remaining = Vec::with_capacity(candidates.len());
+    for candidate in candidates {
+      let owner = owner_by_address.get(&candidate).ok_or_else(|| {
+        format!("aggregate assumption {} has no owning shard", candidate.hex())
+      })?;
+      if !subjects.shards.contains(*owner) {
+        remaining.push(candidate);
+      }
+    }
+    let assumptions = CanonicalTree::from_sorted(remaining)?;
+    Ok(Self::new(subjects, assumptions))
+  }
+}
+
+#[derive(Debug)]
+struct PreparedShard {
+  original_id: u32,
+  statement: Arc<Statement>,
+}
+
+struct PreparedRun {
+  shards: Vec<PreparedShard>,
+  owner_by_address: FxHashMap<Address, usize>,
+  tree: AggNode,
+  env_root: Address,
+  env_count: usize,
+  expected_shards: ShardSet,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum PlanOp {
+  Leaf(usize),
+  Join(usize, usize),
+}
+
+#[derive(Debug)]
+struct SlotSpec {
+  op: PlanOp,
+  statement: Arc<Statement>,
+  subject_count: usize,
+  structural: bool,
+  kind: ChildKind,
+  shape: Option<u8>,
+  outer_claim: Vec<G>,
+  cache_key: Address,
+  ram_bytes: usize,
+}
+
+struct Slot {
+  kind: ChildKind,
+  statement: Arc<Statement>,
+  outer_claim: Vec<G>,
+  proof: AiurProof,
+  proof_address: Option<Address>,
+  claims_bytes: Vec<u8>,
+}
+
+#[derive(Clone, Copy)]
+struct ProveContext<'a> {
+  specs: &'a [SlotSpec],
+  prepared: &'a [PreparedShard],
+  proofs: &'a [Arc<IxonProof>],
+  owner_by_address: &'a FxHashMap<Address, usize>,
+  ixvm_system: &'a AiurSystem,
+  aggr_system: &'a AiurSystem,
+  ixvm_vk: &'a [u8],
+  aggr_vk: &'a [u8],
+  allowed: &'a [u8],
+  verify_idx: usize,
+  aggr_idx: usize,
+  store_dir: &'a Path,
+  cache_dir: Option<&'a Path>,
+}
+
+#[derive(Clone, Copy)]
+struct RunConfig<'a> {
+  ixvm_system: &'a AiurSystem,
+  aggr_system: &'a AiurSystem,
+  env_handle: &'a EnvHandle,
+  manifest_path: &'a Path,
+  proof_hexes: &'a str,
+  verify_idx: usize,
+  aggr_idx: usize,
+  jobs: usize,
+  ram_budget_bytes: usize,
+  structural_above: usize,
+  direct_joins: bool,
+  plan_only: bool,
+  cache_fri_bytes: &'a [u8],
+  use_cache: bool,
+}
+
+fn projection_block(addr: &Address, constant: &Constant) -> Address {
+  match &constant.info {
+    ConstantInfo::IPrj(p) => p.block.clone(),
+    ConstantInfo::CPrj(p) => p.block.clone(),
+    ConstantInfo::RPrj(p) => p.block.clone(),
+    ConstantInfo::DPrj(p) => p.block.clone(),
+    _ => addr.clone(),
+  }
+}
+
+fn prepare_run(
+  env: &ixon::Env,
+  manifest: &ShardManifest,
+) -> Result<PreparedRun, String> {
+  if manifest.shards.is_empty() {
+    return Err("manifest contains no shards".into());
+  }
+
+  let mut block_to_shard = FxHashMap::default();
+  let mut id_to_index = FxHashMap::default();
+  for (index, shard) in manifest.shards.iter().enumerate() {
+    if id_to_index.insert(shard.id, index).is_some() {
+      return Err(format!("manifest repeats shard id {}", shard.id));
+    }
+    for block in &shard.blocks {
+      if let Some(previous) = block_to_shard.insert(block.clone(), index) {
+        return Err(format!(
+          "manifest block {} is owned by shards {} and {}",
+          block.hex(),
+          manifest.shards[previous].id,
+          shard.id
+        ));
+      }
+    }
+  }
+
+  let mut owned = vec![Vec::new(); manifest.shards.len()];
+  let mut owner_old = FxHashMap::default();
+  for entry in env.consts.iter() {
+    let addr = entry.key().clone();
+    let constant = entry.value().get().map_err(|error| {
+      format!("cannot parse environment constant {}: {error}", addr.hex())
+    })?;
+    let block = projection_block(&addr, &constant);
+    let owner = block_to_shard.get(&block).copied().ok_or_else(|| {
+      format!(
+        "environment constant {} (block {}) has no owning manifest shard",
+        addr.hex(),
+        block.hex()
+      )
+    })?;
+    owned[owner].push(addr.clone());
+    owner_old.insert(addr, owner);
+  }
+  if owner_old.len() != env.consts.len() {
+    return Err(
+      "manifest ownership did not cover every environment constant".into(),
+    );
+  }
+
+  let retained_old: Vec<usize> = owned
+    .iter()
+    .enumerate()
+    .filter_map(|(index, addresses)| (!addresses.is_empty()).then_some(index))
+    .collect();
+  if retained_old.is_empty() {
+    return Err("manifest has no shard owning an environment constant".into());
+  }
+  let retained_ids: FxHashSet<u32> =
+    retained_old.iter().map(|index| manifest.shards[*index].id).collect();
+  let source_tree = manifest.tree.clone().unwrap_or_else(|| {
+    let ids: Vec<u32> = manifest.shards.iter().map(|shard| shard.id).collect();
+    AggNode::balanced(&ids).expect("a nonempty id list has a balanced tree")
+  });
+  let tree = source_tree
+    .prune(&|id| retained_ids.contains(&id))
+    .ok_or("pruning removed every aggregate-tree leaf")?;
+
+  let mut old_to_retained = FxHashMap::default();
+  for (retained, old) in retained_old.iter().copied().enumerate() {
+    old_to_retained.insert(old, retained);
+  }
+  let owner_by_address: FxHashMap<Address, usize> = owner_old
+    .into_iter()
+    .map(|(address, old)| {
+      let retained = old_to_retained[&old];
+      (address, retained)
+    })
+    .collect();
+
+  let mut shards = Vec::with_capacity(retained_old.len());
+  for (retained, old) in retained_old.iter().copied().enumerate() {
+    let mut subjects = std::mem::take(&mut owned[old]);
+    subjects.sort_unstable();
+    subjects.dedup();
+    let frontier = thin_frontier(env, &subjects);
+    let subject_tree = SubjectTree::canonical(
+      subjects,
+      ShardSet::singleton(retained, retained_old.len()),
+    )?;
+    let assumptions = CanonicalTree::from_sorted(frontier)?;
+    let statement = Statement::new(subject_tree, assumptions);
+    shards
+      .push(PreparedShard { original_id: manifest.shards[old].id, statement });
+  }
+
+  let mut all_addresses: Vec<Address> =
+    owner_by_address.keys().cloned().collect();
+  all_addresses.sort_unstable();
+  let env_root = merkle_root_canonical_sorted(&all_addresses)
+    .ok_or("cannot aggregate an empty environment")?;
+  let expected_shards = ShardSet(
+    (0..retained_old.len().div_ceil(64))
+      .map(|word| {
+        let remaining = retained_old.len().saturating_sub(word * 64);
+        if remaining >= 64 { u64::MAX } else { (1u64 << remaining) - 1 }
+      })
+      .collect(),
+  );
+
+  Ok(PreparedRun {
+    shards,
+    owner_by_address,
+    tree,
+    env_root,
+    env_count: all_addresses.len(),
+    expected_shards,
+  })
+}
+
+fn merge_sorted(left: &[Address], right: &[Address]) -> Vec<Address> {
+  let mut out = Vec::with_capacity(left.len().saturating_add(right.len()));
+  let (mut i, mut j) = (0, 0);
+  while i < left.len() && j < right.len() {
+    match left[i].cmp(&right[j]) {
+      Ordering::Less => {
+        out.push(left[i].clone());
+        i += 1;
+      },
+      Ordering::Greater => {
+        out.push(right[j].clone());
+        j += 1;
+      },
+      Ordering::Equal => {
+        out.push(left[i].clone());
+        i += 1;
+        j += 1;
+      },
+    }
+  }
+  out.extend_from_slice(&left[i..]);
+  out.extend_from_slice(&right[j..]);
+  out
+}
+
+fn merge_optional_sets(
+  left: Option<&CanonicalTree>,
+  right: Option<&CanonicalTree>,
+) -> Vec<Address> {
+  match (left, right) {
+    (None, None) => Vec::new(),
+    (Some(tree), None) | (None, Some(tree)) => tree.leaves.to_vec(),
+    (Some(left), Some(right)) => merge_sorted(&left.leaves, &right.leaves),
+  }
+}
+
+fn build_plan(
+  tree: &AggNode,
+  shard_by_id: &FxHashMap<u32, usize>,
+  out: &mut Vec<PlanOp>,
+) -> Result<usize, String> {
+  match tree {
+    AggNode::Leaf(id) => {
+      let shard = shard_by_id.get(id).copied().ok_or_else(|| {
+        format!("aggregate tree references missing shard {id}")
+      })?;
+      let index = out.len();
+      out.push(PlanOp::Leaf(shard));
+      Ok(index)
+    },
+    AggNode::Internal(left, right) => {
+      let left_index = build_plan(left, shard_by_id, out)?;
+      let right_index = build_plan(right, shard_by_id, out)?;
+      let index = out.len();
+      out.push(PlanOp::Join(left_index, right_index));
+      Ok(index)
+    },
+  }
+}
+
+fn packed_digest(bytes: &[u8]) -> Vec<G> {
+  let digest = blake3::hash(bytes);
+  digest
+    .as_bytes()
+    .as_chunks::<4>()
+    .0
+    .iter()
+    .map(|word| G::from_u32(u32::from_le_bytes(*word)))
+    .collect()
+}
+
+fn build_claim(fun_idx: usize, input: &[G], output: &[G]) -> Vec<G> {
+  let mut claim = Vec::with_capacity(2 + input.len() + output.len());
+  claim.push(function_channel());
+  claim.push(G::from_usize(fun_idx));
+  claim.extend_from_slice(input);
+  claim.extend_from_slice(output);
+  claim
+}
+
+fn serialize_claims(claims: &[&[G]]) -> Vec<u8> {
+  let mut out = Vec::new();
+  out.extend_from_slice(&(claims.len() as u64).to_le_bytes());
+  for claim in claims {
+    out.extend_from_slice(&(claim.len() as u64).to_le_bytes());
+    for value in *claim {
+      out.extend_from_slice(&value.as_canonical_u64().to_le_bytes());
+    }
+  }
+  out
+}
+
+fn inner_claim(verify_idx: usize, claim_bytes: &[u8]) -> Vec<G> {
+  build_claim(verify_idx, &packed_digest(claim_bytes), &[])
+}
+
+fn aggregate_outer_claim(
+  aggr_idx: usize,
+  allowed: &[u8],
+  claim_bytes: &[u8],
+) -> Vec<G> {
+  let mut input = packed_digest(allowed);
+  input.extend(packed_digest(claim_bytes));
+  build_claim(aggr_idx, &input, &[])
+}
+
+fn allowed_blob(
+  ixvm_vk: &[u8],
+  verify_idx: usize,
+  aggr_vk: &[u8],
+  aggr_idx: usize,
+) -> Vec<u8> {
+  let mut out = Vec::with_capacity(80);
+  out.extend_from_slice(blake3::hash(ixvm_vk).as_bytes());
+  out.extend_from_slice(&(verify_idx as u64).to_le_bytes());
+  out.extend_from_slice(blake3::hash(aggr_vk).as_bytes());
+  out.extend_from_slice(&(aggr_idx as u64).to_le_bytes());
+  out
+}
+
+fn cache_key(
+  aggr_vk: &[u8],
+  cache_fri_bytes: &[u8],
+  outer_claim: &[G],
+) -> Address {
+  let mut bytes = Vec::with_capacity(8 + 32 + cache_fri_bytes.len() + 256);
+  bytes.extend_from_slice(&CACHE_VERSION.to_le_bytes());
+  bytes.extend_from_slice(blake3::hash(aggr_vk).as_bytes());
+  bytes.extend_from_slice(cache_fri_bytes);
+  bytes.extend(serialize_claims(&[outer_claim]));
+  Address::hash(&bytes)
+}
+
+fn shape_code(left: ChildKind, right: Option<ChildKind>) -> u8 {
+  match right {
+    None => left.code(),
+    Some(right) => 2 + 2 * left.code() + right.code(),
+  }
+}
+
+fn structural_shape_code(left: ChildKind, right: ChildKind) -> u8 {
+  6 + 2 * left.code() + right.code()
+}
+
+fn shape_ram_bytes(shape: u8, subject_count: usize) -> usize {
+  match shape {
+    0 | 1 => WRAP_RAM_BYTES,
+    3 | 4 | 7 | 8 => MIXED_RAM_BYTES,
+    5 => STRUCTURAL_RAM_BYTES
+      .saturating_add(subject_count.saturating_mul(FLAT_RAM_PER_SUBJECT)),
+    9 => STRUCTURAL_RAM_BYTES,
+    // Shapes 2/6 are direct pairs; unknown shapes retain the conservative
+    // direct-pair fallback used by the Lean reference scheduler.
+    _ => DIRECT_RAM_BYTES,
+  }
+}
+
+fn build_specs(
+  prepared: &PreparedRun,
+  verify_idx: usize,
+  aggr_idx: usize,
+  structural_above: usize,
+  direct_joins: bool,
+  aggr_vk: &[u8],
+  allowed: &[u8],
+  cache_fri_bytes: &[u8],
+) -> Result<Vec<SlotSpec>, String> {
+  let shard_by_id: FxHashMap<u32, usize> = prepared
+    .shards
+    .iter()
+    .enumerate()
+    .map(|(index, shard)| (shard.original_id, index))
+    .collect();
+  let mut ops = Vec::new();
+  build_plan(&prepared.tree, &shard_by_id, &mut ops)?;
+  let raw_leaves = direct_joins && ops.len() > 1;
+  let mut specs: Vec<SlotSpec> = Vec::with_capacity(ops.len());
+  for op in ops {
+    match op {
+      PlanOp::Leaf(shard) => {
+        let prepared_shard = &prepared.shards[shard];
+        let kind = if raw_leaves { ChildKind::Ixvm } else { ChildKind::Aggr };
+        let shape = (!raw_leaves).then_some(shape_code(ChildKind::Ixvm, None));
+        let outer_claim = if raw_leaves {
+          inner_claim(verify_idx, &prepared_shard.statement.claim_bytes)
+        } else {
+          aggregate_outer_claim(
+            aggr_idx,
+            allowed,
+            &prepared_shard.statement.claim_bytes,
+          )
+        };
+        let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim);
+        specs.push(SlotSpec {
+          op,
+          statement: prepared_shard.statement.clone(),
+          subject_count: prepared_shard.statement.subjects.count,
+          structural: false,
+          kind,
+          shape,
+          outer_claim,
+          cache_key: key,
+          ram_bytes: shape.map_or(RAW_SHARD_RAM_BYTES, |value| {
+            shape_ram_bytes(value, prepared_shard.statement.subjects.count)
+          }),
+        });
+      },
+      PlanOp::Join(left_index, right_index) => {
+        let left = specs
+          .get(left_index)
+          .ok_or("aggregate plan has a missing left child")?;
+        let right = specs
+          .get(right_index)
+          .ok_or("aggregate plan has a missing right child")?;
+        let subject_count =
+          left.subject_count.saturating_add(right.subject_count);
+        let structural = subject_count > structural_above;
+        let shape = if structural {
+          structural_shape_code(left.kind, right.kind)
+        } else {
+          shape_code(left.kind, Some(right.kind))
+        };
+        let statement = Statement::join(
+          &left.statement,
+          &right.statement,
+          structural,
+          &prepared.owner_by_address,
+        )?;
+        if statement.subjects.count != subject_count {
+          return Err("aggregate plan has inconsistent subject counts".into());
+        }
+        let outer_claim =
+          aggregate_outer_claim(aggr_idx, allowed, &statement.claim_bytes);
+        let key = cache_key(aggr_vk, cache_fri_bytes, &outer_claim);
+        specs.push(SlotSpec {
+          op,
+          statement,
+          subject_count,
+          structural,
+          kind: ChildKind::Aggr,
+          shape: Some(shape),
+          outer_claim,
+          cache_key: key,
+          ram_bytes: shape_ram_bytes(shape, subject_count),
+        });
+      },
+    }
+  }
+  Ok(specs)
+}
+
+fn store_path(root: &Path, address: &Address) -> PathBuf {
+  let hex = address.hex();
+  root.join(&hex[0..2]).join(&hex[2..4]).join(&hex[4..6]).join(&hex[6..])
+}
+
+fn read_store(root: &Path, address: &Address) -> Result<Vec<u8>, String> {
+  let path = store_path(root, address);
+  fs::read(&path).map_err(|error| format!("read {}: {error}", path.display()))
+}
+
+fn write_store(root: &Path, bytes: &[u8]) -> Result<Address, String> {
+  let address = Address::hash(bytes);
+  let path = store_path(root, &address);
+  let parent = path.parent().ok_or("store path has no parent")?;
+  fs::create_dir_all(parent)
+    .map_err(|error| format!("create {}: {error}", parent.display()))?;
+  fs::write(&path, bytes)
+    .map_err(|error| format!("write {}: {error}", path.display()))?;
+  Ok(address)
+}
+
+fn decode_wrapper(bytes: &[u8]) -> Result<IxonProof, String> {
+  let mut cursor = bytes;
+  let proof = IxonProof::get(&mut cursor)?;
+  if !cursor.is_empty() {
+    return Err(format!("{} trailing bytes after proof wrapper", cursor.len()));
+  }
+  Ok(proof)
+}
+
+fn load_input_proofs(
+  proof_hexes: &str,
+  store_dir: &Path,
+  prepared: &[PreparedShard],
+) -> Result<Vec<Arc<IxonProof>>, String> {
+  let values: Vec<&str> =
+    proof_hexes.lines().filter(|line| !line.is_empty()).collect();
+  if values.len() != prepared.len() {
+    return Err(format!(
+      "aggregate requires exactly {} shard proofs; got {}",
+      prepared.len(),
+      values.len()
+    ));
+  }
+  let by_digest: FxHashMap<Address, usize> = prepared
+    .iter()
+    .enumerate()
+    .map(|(index, shard)| (Address::hash(&shard.statement.claim_bytes), index))
+    .collect();
+  if by_digest.len() != prepared.len() {
+    return Err("two reconstructed shard claims have the same digest".into());
+  }
+  let mut proofs: Vec<Option<Arc<IxonProof>>> = vec![None; prepared.len()];
+  for value in values {
+    let address = Address::from_hex(value).ok_or_else(|| {
+      format!("shard proof is not a 64-character address: {value}")
+    })?;
+    let bytes = read_store(store_dir, &address)?;
+    if Address::hash(&bytes) != address {
+      return Err(format!(
+        "shard proof store object {} has the wrong digest",
+        address.hex()
+      ));
+    }
+    let wrapper = decode_wrapper(&bytes).map_err(|error| {
+      format!("decode shard proof {}: {error}", address.hex())
+    })?;
+    let mut claim_bytes = Vec::new();
+    wrapper.claim.put(&mut claim_bytes);
+    let digest = Address::hash(&claim_bytes);
+    let shard = by_digest.get(&digest).copied().ok_or_else(|| {
+      format!("proof {} matches no manifest shard", address.hex())
+    })?;
+    if wrapper.claim != prepared[shard].statement.claim {
+      return Err(format!(
+        "proof {} hit a claim-digest collision for shard {}",
+        address.hex(),
+        prepared[shard].original_id
+      ));
+    }
+    if proofs[shard].is_some() {
+      return Err(format!(
+        "more than one proof supplied for shard {}",
+        prepared[shard].original_id
+      ));
+    }
+    proofs[shard] = Some(Arc::new(wrapper));
+  }
+  proofs
+    .into_iter()
+    .enumerate()
+    .map(|(index, proof)| {
+      proof.ok_or_else(|| {
+        format!("no proof supplied for shard {}", prepared[index].original_id)
+      })
+    })
+    .collect()
+}
+
+fn cache_address(cache_dir: &Path, key: &Address) -> Option<Address> {
+  let path = cache_dir.join(key.hex());
+  let raw = fs::read_to_string(path).ok()?;
+  Address::from_hex(raw.trim())
+}
+
+fn load_cached(
+  ctx: ProveContext<'_>,
+  slot_index: usize,
+  spec: &SlotSpec,
+) -> Option<(AiurProof, Address)> {
+  let cache_dir = ctx.cache_dir?;
+  let address = cache_address(cache_dir, &spec.cache_key)?;
+  let reject = |reason: &str| {
+    eprintln!(
+      "[aggregate] slot {slot_index}: cache miss (wrapper {} rejected: {reason})",
+      address.hex()
+    );
+  };
+  let bytes = match read_store(ctx.store_dir, &address) {
+    Ok(bytes) => bytes,
+    Err(error) => {
+      reject(&error);
+      return None;
+    },
+  };
+  if Address::hash(&bytes) != address {
+    reject("store object has a different content digest");
+    return None;
+  }
+  let wrapper = match decode_wrapper(&bytes) {
+    Ok(wrapper) => wrapper,
+    Err(error) => {
+      reject(&error);
+      return None;
+    },
+  };
+  if wrapper.claim != spec.statement.claim {
+    reject("bundled claim does not match the expected statement");
+    return None;
+  }
+  let proof = match AiurProof::from_bytes(&wrapper.proof) {
+    Ok(proof) => proof,
+    Err(error) => {
+      reject(&format!("proof deserialization failed: {error}"));
+      return None;
+    },
+  };
+  if let Err(error) = ctx.aggr_system.verify(&spec.outer_claim, &proof) {
+    reject(&format!("native verification failed: {error:?}"));
+    return None;
+  }
+  eprintln!("[aggregate] slot {slot_index}: cache hit {}", address.hex());
+  Some((proof, address))
+}
+
+fn persist_wrapper(
+  store_dir: &Path,
+  statement: &Statement,
+  proof: &AiurProof,
+) -> Result<Address, String> {
+  write_store(store_dir, &statement.claim_bytes)?;
+  let proof_bytes = proof.to_bytes().map_err(|error| {
+    format!("aggregate proof serialization failed: {error}")
+  })?;
+  let wrapper = IxonProof::new(statement.claim.clone(), proof_bytes);
+  let mut bytes = Vec::new();
+  wrapper.put(&mut bytes);
+  write_store(store_dir, &bytes)
+}
+
+fn persist_cached(
+  ctx: ProveContext<'_>,
+  slot_index: usize,
+  spec: &SlotSpec,
+  proof: &AiurProof,
+) -> Option<Address> {
+  let cache_dir = ctx.cache_dir?;
+  match (|| -> Result<Address, String> {
+    let address = persist_wrapper(ctx.store_dir, &spec.statement, proof)?;
+    fs::create_dir_all(cache_dir).map_err(|error| {
+      format!("create aggregate cache {}: {error}", cache_dir.display())
+    })?;
+    let destination = cache_dir.join(spec.cache_key.hex());
+    let temporary = cache_dir.join(format!(
+      "{}.tmp.{}.{}",
+      spec.cache_key.hex(),
+      std::process::id(),
+      slot_index
+    ));
+    fs::write(&temporary, format!("{}\n", address.hex())).map_err(|error| {
+      format!("write cache index {}: {error}", temporary.display())
+    })?;
+    fs::rename(&temporary, &destination).map_err(|error| {
+      format!(
+        "publish cache index {} -> {}: {error}",
+        temporary.display(),
+        destination.display()
+      )
+    })?;
+    Ok(address)
+  })() {
+    Ok(address) => {
+      eprintln!(
+        "[aggregate] slot {slot_index}: cached proof {}",
+        address.hex()
+      );
+      Some(address)
+    },
+    Err(error) => {
+      eprintln!(
+        "[aggregate] slot {slot_index}: warning: could not persist cache entry: {error}"
+      );
+      None
+    },
+  }
+}
+
+struct OwnedTreeAdvice {
+  root: [u8; 32],
+  bytes: Vec<u8>,
+}
+
+fn push_canonical_tree(out: &mut Vec<OwnedTreeAdvice>, tree: &CanonicalTree) {
+  out.push(OwnedTreeAdvice {
+    root: *tree.root.as_bytes(),
+    bytes: tree.serialized().to_vec(),
+  });
+}
+
+fn path_payload(path: Option<&MerklePath>) -> Result<Vec<u8>, String> {
+  let Some(path) = path else {
+    return Ok(vec![0]);
+  };
+  let length = u8::try_from(path.len()).map_err(|_overflow| {
+    format!("aggregate Merkle path has {} steps", path.len())
+  })?;
+  if length > 64 {
+    return Err(format!(
+      "aggregate Merkle path has {length} steps (maximum 64)"
+    ));
+  }
+  let mut out = Vec::with_capacity(2 + path.len() * 33);
+  out.extend([1, length]);
+  for (sibling, is_left) in path {
+    out.push(if *is_left { 0 } else { 1 });
+    out.extend_from_slice(sibling.as_bytes());
+  }
+  Ok(out)
+}
+
+fn tree_advice(
+  left: &Statement,
+  right: &Statement,
+  output: &Statement,
+  structural: bool,
+) -> Result<Vec<OwnedTreeAdvice>, String> {
+  let mut trees = Vec::new();
+  if !structural {
+    let left_subjects = left
+      .subjects
+      .canonical_tree()
+      .ok_or("flat join has structural left subjects")?;
+    push_canonical_tree(&mut trees, left_subjects);
+  }
+  if let Some(tree) = &left.assumptions {
+    push_canonical_tree(&mut trees, tree);
+  }
+  if !structural {
+    let right_subjects = right
+      .subjects
+      .canonical_tree()
+      .ok_or("flat join has structural right subjects")?;
+    push_canonical_tree(&mut trees, right_subjects);
+  }
+  if let Some(tree) = &right.assumptions {
+    push_canonical_tree(&mut trees, tree);
+  }
+  if !structural {
+    let output_subjects = output
+      .subjects
+      .canonical_tree()
+      .ok_or("flat join produced structural subjects")?;
+    push_canonical_tree(&mut trees, output_subjects);
+  }
+  if let Some(tree) = &output.assumptions {
+    push_canonical_tree(&mut trees, tree);
+  }
+  Ok(trees)
+}
+
+fn structural_path_advice(
+  left: &Statement,
+  right: &Statement,
+  output: &Statement,
+  owner_by_address: &FxHashMap<Address, usize>,
+) -> Result<Vec<(Address, Vec<u8>)>, String> {
+  let candidates = merge_optional_sets(
+    left.assumptions.as_deref(),
+    right.assumptions.as_deref(),
+  );
+  let mut paths = Vec::with_capacity(candidates.len());
+  for candidate in candidates {
+    let owner = owner_by_address.get(&candidate).ok_or_else(|| {
+      format!("aggregate assumption {} has no owning shard", candidate.hex())
+    })?;
+    let path = output.subjects.merkle_proof(&candidate, *owner);
+    paths.push((candidate, path_payload(path.as_ref())?));
+  }
+  Ok(paths)
+}
+
+fn prove_aggregate(
+  ctx: ProveContext<'_>,
+  spec: &SlotSpec,
+  left: &Slot,
+  right: Option<&Slot>,
+  slot_index: usize,
+) -> Result<(AiurProof, Option<Address>), String> {
+  if let Some((proof, address)) = load_cached(ctx, slot_index, spec) {
+    return Ok((proof, Some(address)));
+  }
+
+  let left_system = match left.kind {
+    ChildKind::Ixvm => ctx.ixvm_system,
+    ChildKind::Aggr => ctx.aggr_system,
+  };
+  let left_advice = left_system
+    .proof_to_advice_bytes(&left.outer_claim, &left.proof)
+    .map_err(|error| format!("left child proof advice failed: {error:?}"))?;
+  let right_advice = if let Some(right) = right {
+    let system = match right.kind {
+      ChildKind::Ixvm => ctx.ixvm_system,
+      ChildKind::Aggr => ctx.aggr_system,
+    };
+    system
+      .proof_to_advice_bytes(&right.outer_claim, &right.proof)
+      .map_err(|error| format!("right child proof advice failed: {error:?}"))?
+  } else {
+    Vec::new()
+  };
+
+  let mut preimage_storage = Vec::new();
+  if let Some(right) = right {
+    preimage_storage.push((
+      *blake3::hash(&left.statement.claim_bytes).as_bytes(),
+      left.statement.claim_bytes.as_slice(),
+    ));
+    preimage_storage.push((
+      *blake3::hash(&right.statement.claim_bytes).as_bytes(),
+      right.statement.claim_bytes.as_slice(),
+    ));
+  }
+  let preimages: Vec<AggrPreimage<'_>> = preimage_storage
+    .iter()
+    .map(|(digest, bytes)| AggrPreimage { digest: *digest, bytes })
+    .collect();
+
+  let (tree_storage, path_storage) = if let Some(right) = right {
+    (
+      tree_advice(
+        &left.statement,
+        &right.statement,
+        &spec.statement,
+        spec.structural,
+      )?,
+      if spec.structural {
+        structural_path_advice(
+          &left.statement,
+          &right.statement,
+          &spec.statement,
+          ctx.owner_by_address,
+        )?
+      } else {
+        Vec::new()
+      },
+    )
+  } else {
+    (Vec::new(), Vec::new())
+  };
+  let trees: Vec<AggrTree<'_>> = tree_storage
+    .iter()
+    .map(|tree| AggrTree { root: tree.root, bytes: &tree.bytes })
+    .collect();
+  let paths: Vec<AggrPath<'_>> = path_storage
+    .iter()
+    .map(|(candidate, bytes)| AggrPath {
+      candidate: *candidate.as_bytes(),
+      bytes,
+    })
+    .collect();
+  let empty = Vec::new();
+  let right_claims =
+    right.map_or(empty.as_slice(), |slot| slot.claims_bytes.as_slice());
+  let shape = spec.shape.ok_or("aggregate proof slot has no shape")?;
+  let mut io = aggr_io_buffer(&AggrAdvice {
+    shape,
+    proof_advice: [&left_advice, &right_advice],
+    ixvm_vk: ctx.ixvm_vk,
+    self_vk: ctx.aggr_vk,
+    child_claims: [&left.claims_bytes, right_claims],
+    output_claim: &spec.statement.claim_bytes,
+    allowed: ctx.allowed,
+    preimages: &preimages,
+    trees: &trees,
+    paths: &paths,
+  });
+  let mut public_input = packed_digest(ctx.allowed);
+  public_input.extend(packed_digest(&spec.statement.claim_bytes));
+  let (outer_claim, proof) = ctx.aggr_system.prove_ixvm(
+    ctx.aggr_idx,
+    &public_input,
+    &mut io,
+    execute_ix_aggr,
+  );
+  if outer_claim != spec.outer_claim {
+    return Err("aggregate prover returned an unexpected outer claim".into());
+  }
+  let address = persist_cached(ctx, slot_index, spec, &proof);
+  Ok((proof, address))
+}
+
+fn prove_slot(
+  ctx: ProveContext<'_>,
+  slot_index: usize,
+  children: &[Arc<Slot>],
+) -> Result<Arc<Slot>, String> {
+  let spec = ctx.specs.get(slot_index).ok_or("missing aggregate slot spec")?;
+  match spec.op {
+    PlanOp::Leaf(shard) => {
+      let prepared = &ctx.prepared[shard];
+      let wrapper = &ctx.proofs[shard];
+      let proof = AiurProof::from_bytes(&wrapper.proof).map_err(|error| {
+        format!("shard {} proof does not decode: {error}", prepared.original_id)
+      })?;
+      let inner = inner_claim(ctx.verify_idx, &prepared.statement.claim_bytes);
+      ctx.ixvm_system.verify(&inner, &proof).map_err(|error| {
+        format!(
+          "shard {} proof fails native verification: {error:?}",
+          prepared.original_id
+        )
+      })?;
+      let inner_claims = serialize_claims(&[&inner]);
+      if spec.kind == ChildKind::Ixvm {
+        if spec.outer_claim != inner {
+          return Err("direct shard slot has an unexpected outer claim".into());
+        }
+        return Ok(Arc::new(Slot {
+          kind: ChildKind::Ixvm,
+          statement: spec.statement.clone(),
+          outer_claim: inner,
+          proof,
+          proof_address: None,
+          claims_bytes: inner_claims,
+        }));
+      }
+      eprintln!(
+        "[aggregate] wrapping shard {} into slot {slot_index}",
+        prepared.original_id
+      );
+      let raw = Slot {
+        kind: ChildKind::Ixvm,
+        statement: spec.statement.clone(),
+        outer_claim: inner,
+        proof,
+        proof_address: None,
+        claims_bytes: inner_claims,
+      };
+      let (proof, proof_address) =
+        prove_aggregate(ctx, spec, &raw, None, slot_index)?;
+      Ok(Arc::new(Slot {
+        kind: ChildKind::Aggr,
+        statement: spec.statement.clone(),
+        outer_claim: spec.outer_claim.clone(),
+        proof,
+        proof_address,
+        claims_bytes: serialize_claims(&[&spec.outer_claim]),
+      }))
+    },
+    PlanOp::Join(left_index, right_index) => {
+      if children.len() != 2 {
+        return Err("aggregate join did not receive two children".into());
+      }
+      let left = &children[0];
+      let right = &children[1];
+      let mode = if spec.structural { "structural" } else { "flat" };
+      eprintln!(
+        "[aggregate] {mode}-joining slots {left_index}, {right_index} into {slot_index}"
+      );
+      let (proof, proof_address) =
+        prove_aggregate(ctx, spec, left, Some(right), slot_index)?;
+      Ok(Arc::new(Slot {
+        kind: ChildKind::Aggr,
+        statement: spec.statement.clone(),
+        outer_claim: spec.outer_claim.clone(),
+        proof,
+        proof_address,
+        claims_bytes: serialize_claims(&[&spec.outer_claim]),
+      }))
+    },
+  }
+}
+
+fn dependencies_complete(spec: &SlotSpec, completed: &[bool]) -> bool {
+  match spec.op {
+    PlanOp::Leaf(_) => true,
+    PlanOp::Join(left, right) => completed[left] && completed[right],
+  }
+}
+
+fn run_scheduler(
+  ctx: ProveContext<'_>,
+  jobs: usize,
+  budget: usize,
+) -> Result<Vec<Arc<Slot>>, String> {
+  if budget == 0 {
+    return Err("aggregate scheduler RAM budget must be positive".into());
+  }
+  let max_jobs = if jobs == 0 { ctx.specs.len().max(1) } else { jobs.max(1) };
+  let (sender, receiver) = mpsc::channel();
+  thread::scope(|scope| -> Result<Vec<Arc<Slot>>, String> {
+    let mut slots: Vec<Option<Arc<Slot>>> = vec![None; ctx.specs.len()];
+    let mut completed = vec![false; ctx.specs.len()];
+    let mut in_flight = vec![false; ctx.specs.len()];
+    let mut completed_count = 0usize;
+    let mut active = 0usize;
+    let mut reserved = 0usize;
+    let mut failures: Vec<(usize, String)> = Vec::new();
+
+    while completed_count < ctx.specs.len() {
+      if failures.is_empty() && active < max_jobs {
+        let mut ready: Vec<usize> = ctx
+          .specs
+          .iter()
+          .enumerate()
+          .filter_map(|(index, spec)| {
+            (!completed[index]
+              && !in_flight[index]
+              && dependencies_complete(spec, &completed))
+            .then_some(index)
+          })
+          .collect();
+        ready.sort_unstable_by(|left, right| {
+          ctx.specs[*right]
+            .ram_bytes
+            .cmp(&ctx.specs[*left].ram_bytes)
+            .then_with(|| left.cmp(right))
+        });
+        for index in ready {
+          if active >= max_jobs {
+            break;
+          }
+          let weight = ctx.specs[index].ram_bytes;
+          let fits = reserved.saturating_add(weight) <= budget;
+          if !fits && active != 0 {
+            continue;
+          }
+          let children = match ctx.specs[index].op {
+            PlanOp::Leaf(_) => Vec::new(),
+            PlanOp::Join(left, right) => vec![
+              slots[left].as_ref().expect("completed left slot").clone(),
+              slots[right].as_ref().expect("completed right slot").clone(),
+            ],
+          };
+          in_flight[index] = true;
+          active += 1;
+          reserved = reserved.saturating_add(weight);
+          let over =
+            if weight > budget { "; over-budget slot runs alone" } else { "" };
+          eprintln!(
+            "[aggregate] slot {index}: admitted {} GiB; reserved {}/{} GiB; active {active}/{max_jobs}{over}",
+            format_gib(weight),
+            format_gib(reserved),
+            format_gib(budget),
+          );
+          let sender = sender.clone();
+          scope.spawn(move || {
+            let result =
+              std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                prove_slot(ctx, index, &children)
+              }))
+              .unwrap_or_else(|payload| {
+                Err(format!(
+                  "Rust proof worker panicked: {}",
+                  panic_text(&payload)
+                ))
+              });
+            let _ = sender.send((index, weight, result));
+          });
+        }
+      }
+
+      if active == 0 {
+        if failures.is_empty() {
+          failures
+            .push((ctx.specs.len(), "aggregate scheduler deadlocked".into()));
+        }
+        break;
+      }
+
+      let (index, weight, result) = receiver.recv().map_err(|error| {
+        format!("aggregate scheduler channel closed: {error}")
+      })?;
+      if !in_flight.get(index).copied().unwrap_or(false) {
+        failures.push((index, "duplicate or unknown scheduler result".into()));
+        continue;
+      }
+      in_flight[index] = false;
+      active -= 1;
+      reserved = reserved.saturating_sub(weight);
+      match result {
+        Ok(slot) => {
+          slots[index] = Some(slot);
+          completed[index] = true;
+          completed_count += 1;
+        },
+        Err(error) => failures.push((index, error)),
+      }
+    }
+
+    while active > 0 {
+      let (index, weight, result) = receiver.recv().map_err(|error| {
+        format!("aggregate scheduler drain failed: {error}")
+      })?;
+      if in_flight.get(index).copied().unwrap_or(false) {
+        in_flight[index] = false;
+        active -= 1;
+        reserved = reserved.saturating_sub(weight);
+      }
+      match result {
+        Ok(slot) => {
+          slots[index] = Some(slot);
+          completed[index] = true;
+        },
+        Err(error) => failures.push((index, error)),
+      }
+    }
+    if !failures.is_empty() {
+      failures.sort_unstable_by_key(|(index, _)| *index);
+      let (index, error) = failures.remove(0);
+      return Err(if index < ctx.specs.len() {
+        format!("slot {index}: {error}")
+      } else {
+        error
+      });
+    }
+    slots
+      .into_iter()
+      .enumerate()
+      .map(|(index, slot)| {
+        slot.ok_or_else(|| format!("scheduler completed without slot {index}"))
+      })
+      .collect()
+  })
+}
+
+fn print_plan(
+  specs: &[SlotSpec],
+  prepared: &[PreparedShard],
+  threshold: usize,
+) {
+  let leaves =
+    specs.iter().filter(|spec| matches!(spec.op, PlanOp::Leaf(_))).count();
+  let wraps = specs
+    .iter()
+    .filter(|spec| {
+      matches!(spec.op, PlanOp::Leaf(_)) && spec.kind == ChildKind::Aggr
+    })
+    .count();
+  let structural = specs.iter().filter(|spec| spec.structural).count();
+  let policy = if wraps == leaves {
+    format!("{wraps} wraps")
+  } else {
+    format!("{} direct IxVM leaves", leaves - wraps)
+  };
+  eprintln!(
+    "[aggregate] plan: {policy} + {} binary joins ({structural} structural; threshold > {threshold} subject leaves)",
+    specs.len() - leaves
+  );
+  for (index, spec) in specs.iter().enumerate() {
+    match spec.op {
+      PlanOp::Leaf(shard) => {
+        let mode =
+          if spec.kind == ChildKind::Ixvm { "raw shard" } else { "wrap shard" };
+        eprintln!(
+          "  slot {index}: {mode} {} ({} subjects)",
+          prepared[shard].original_id, spec.subject_count
+        );
+      },
+      PlanOp::Join(left, right) => {
+        let mode = if spec.structural { "structural" } else { "flat" };
+        eprintln!(
+          "  slot {index}: {mode} shape {} slots {left}, {right} ({} subjects)",
+          spec.shape.unwrap_or(u8::MAX),
+          spec.subject_count
+        );
+      },
+    }
+  }
+}
+
+fn run(config: RunConfig<'_>) -> Result<String, String> {
+  if config.cache_fri_bytes.len() != 40 {
+    return Err(format!(
+      "aggregate cache FRI serialization is {} bytes, expected 40",
+      config.cache_fri_bytes.len()
+    ));
+  }
+  let started = Instant::now();
+  let manifest_bytes = fs::read(config.manifest_path).map_err(|error| {
+    format!("read manifest {}: {error}", config.manifest_path.display())
+  })?;
+  let manifest = ShardManifest::from_bytes(&manifest_bytes)
+    .map_err(|error| format!("manifest parse failed: {error}"))?;
+  let parsed_at = Instant::now();
+  let prepared = prepare_run(&config.env_handle.env, &manifest)?;
+  let prepared_at = Instant::now();
+
+  let ixvm_vk = aiur::vk_codec::aiur_system_to_bytes(config.ixvm_system)
+    .map_err(|error| format!("IxVM VK serialization failed: {error}"))?;
+  let aggr_vk = aiur::vk_codec::aiur_system_to_bytes(config.aggr_system)
+    .map_err(|error| format!("ixAggr VK serialization failed: {error}"))?;
+  let allowed =
+    allowed_blob(&ixvm_vk, config.verify_idx, &aggr_vk, config.aggr_idx);
+  let specs = build_specs(
+    &prepared,
+    config.verify_idx,
+    config.aggr_idx,
+    config.structural_above,
+    config.direct_joins,
+    &aggr_vk,
+    &allowed,
+    config.cache_fri_bytes,
+  )?;
+  let specs_at = Instant::now();
+  print_plan(&specs, &prepared.shards, config.structural_above);
+  if config.plan_only {
+    eprintln!(
+      "[aggregate] Rust plan startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s; total {:.3}s",
+      (parsed_at - started).as_secs_f64(),
+      (prepared_at - parsed_at).as_secs_f64(),
+      (specs_at - prepared_at).as_secs_f64(),
+      (specs_at - started).as_secs_f64(),
+    );
+    return Ok(String::new());
+  }
+
+  let home = std::env::var_os("HOME").ok_or("no HOME environment variable")?;
+  let ix_root = PathBuf::from(home).join(".ix");
+  let store_dir = ix_root.join("store");
+  let cache_path = ix_root.join("cache").join("aggregate");
+  let cache_dir = config.use_cache.then_some(cache_path.as_path());
+  if let Some(dir) = cache_dir {
+    fs::create_dir_all(dir).map_err(|error| {
+      format!("create aggregate cache {}: {error}", dir.display())
+    })?;
+  } else {
+    eprintln!("[aggregate] cache disabled (--no-cache)");
+  }
+  let proofs =
+    load_input_proofs(config.proof_hexes, &store_dir, &prepared.shards)?;
+  let proofs_at = Instant::now();
+  eprintln!(
+    "[aggregate] Rust startup: manifest {:.3}s, env/claims {:.3}s, plan/statements {:.3}s, proofs {:.3}s; total {:.3}s",
+    (parsed_at - started).as_secs_f64(),
+    (prepared_at - parsed_at).as_secs_f64(),
+    (specs_at - prepared_at).as_secs_f64(),
+    (proofs_at - specs_at).as_secs_f64(),
+    (proofs_at - started).as_secs_f64(),
+  );
+  let jobs_label = if config.jobs == 0 {
+    "all ready slots".to_string()
+  } else {
+    config.jobs.to_string()
+  };
+  eprintln!(
+    "[aggregate] scheduler: jobs={jobs_label}, RAM budget {} GiB; wrap/self 195.0 GiB, direct 390.0 GiB, mixed 340.0 GiB, flat +1 MiB/subject",
+    format_gib(config.ram_budget_bytes)
+  );
+
+  let context = ProveContext {
+    specs: &specs,
+    prepared: &prepared.shards,
+    proofs: &proofs,
+    owner_by_address: &prepared.owner_by_address,
+    ixvm_system: config.ixvm_system,
+    aggr_system: config.aggr_system,
+    ixvm_vk: &ixvm_vk,
+    aggr_vk: &aggr_vk,
+    allowed: &allowed,
+    verify_idx: config.verify_idx,
+    aggr_idx: config.aggr_idx,
+    store_dir: &store_dir,
+    cache_dir,
+  };
+  let slots = run_scheduler(context, config.jobs, config.ram_budget_bytes)?;
+  let root = slots.last().ok_or("aggregate plan produced no root slot")?;
+  if root.kind != ChildKind::Aggr {
+    return Err("aggregate plan produced a raw IxVM root".into());
+  }
+  if root.statement.subjects.count != prepared.env_count {
+    return Err(format!(
+      "aggregate root has {} subjects, environment has {}",
+      root.statement.subjects.count, prepared.env_count
+    ));
+  }
+  if root.statement.subjects.shards != prepared.expected_shards {
+    return Err("aggregate root does not contain every retained shard".into());
+  }
+  let mut root_leaves = Vec::with_capacity(prepared.env_count);
+  root.statement.subjects.collect_leaves(&mut root_leaves);
+  root_leaves.sort_unstable();
+  root_leaves.dedup();
+  let canonical_root = merkle_root_canonical_sorted(&root_leaves)
+    .ok_or("aggregate root has no subject leaves")?;
+  if canonical_root != prepared.env_root {
+    return Err(format!(
+      "aggregate root subjects canonicalize to {}, not environment root {}",
+      canonical_root.hex(),
+      prepared.env_root.hex()
+    ));
+  }
+  if root.statement.assumptions.is_some() {
+    return Err("aggregate root retains undischarged assumptions".into());
+  }
+  config.aggr_system.verify(&root.outer_claim, &root.proof).map_err(
+    |error| format!("aggregate root proof failed verification: {error:?}"),
+  )?;
+  let address = match &root.proof_address {
+    Some(address) => address.clone(),
+    None => persist_wrapper(&store_dir, &root.statement, &root.proof)?,
+  };
+  eprintln!("[aggregate] root proof: {}", address.hex());
+  Ok(address.hex())
+}
+
+fn panic_text(payload: &Box<dyn std::any::Any + Send>) -> &str {
+  payload
+    .downcast_ref::<&str>()
+    .copied()
+    .or_else(|| payload.downcast_ref::<String>().map(String::as_str))
+    .unwrap_or("unknown Rust panic")
+}
+
+/// Production FFI called once after Lean has compiled the IxVM and ixAggr
+/// systems. Proof addresses are newline-separated to keep the ABI flat.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_stage2_aggregate(
+  ixvm_system: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  aggr_system: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  env_handle: LeanExternal<EnvHandle, LeanBorrowed<'_>>,
+  manifest_path: LeanString<LeanBorrowed<'_>>,
+  proof_hexes: LeanString<LeanBorrowed<'_>>,
+  verify_idx: LeanNat<LeanBorrowed<'_>>,
+  aggr_idx: LeanNat<LeanBorrowed<'_>>,
+  jobs: LeanNat<LeanBorrowed<'_>>,
+  ram_budget_bytes: LeanNat<LeanBorrowed<'_>>,
+  structural_above: LeanNat<LeanBorrowed<'_>>,
+  direct_joins: bool,
+  plan_only: bool,
+  cache_fri_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  use_cache: bool,
+) -> LeanExcept<LeanOwned> {
+  let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+    run(RunConfig {
+      ixvm_system: ixvm_system.get(),
+      aggr_system: aggr_system.get(),
+      env_handle: env_handle.get(),
+      manifest_path: Path::new(manifest_path.as_str()),
+      proof_hexes: proof_hexes.as_str(),
+      verify_idx: lean_unbox_nat_as_usize(verify_idx.inner()),
+      aggr_idx: lean_unbox_nat_as_usize(aggr_idx.inner()),
+      jobs: lean_unbox_nat_as_usize(jobs.inner()),
+      ram_budget_bytes: lean_unbox_nat_as_usize(ram_budget_bytes.inner()),
+      structural_above: lean_unbox_nat_as_usize(structural_above.inner()),
+      direct_joins,
+      plan_only,
+      cache_fri_bytes: cache_fri_bytes.as_bytes(),
+      use_cache,
+    })
+  }));
+  match result {
+    Ok(Ok(address)) => LeanExcept::ok(LeanString::new(&address)),
+    Ok(Err(error)) => LeanExcept::error_string(&error),
+    Err(payload) => LeanExcept::error_string(&format!(
+      "native Stage 2 orchestration panicked: {}",
+      panic_text(&payload)
+    )),
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use ix_kernel::shard::ShardInfo;
+  use ixon::{Axiom, Expr};
+
+  fn addr(label: &str) -> Address {
+    Address::hash(label.as_bytes())
+  }
+
+  #[test]
+  fn sorted_merge_is_a_set_union() {
+    let a = addr("a");
+    let b = addr("b");
+    let c = addr("c");
+    let mut left = vec![a.clone(), c.clone()];
+    let mut right = vec![b.clone(), c.clone()];
+    left.sort_unstable();
+    right.sort_unstable();
+    let merged = merge_sorted(&left, &right);
+    assert_eq!(merged.len(), 3);
+    assert!(merged.windows(2).all(|window| window[0] < window[1]));
+  }
+
+  #[test]
+  fn cached_canonical_path_matches_root() {
+    let mut leaves: Vec<Address> =
+      (0..17).map(|index| addr(&format!("leaf-{index}"))).collect();
+    leaves.sort_unstable();
+    let tree = CanonicalTree::from_sorted(leaves.clone()).unwrap().unwrap();
+    for leaf in leaves {
+      let path = tree.merkle_proof(&leaf).expect("member path");
+      assert!(ixon::merkle::verify_merkle_proof(&tree.root, &leaf, &path));
+    }
+  }
+
+  #[test]
+  fn structural_path_uses_cached_child_roots() {
+    let mut left_leaves = vec![addr("a"), addr("b")];
+    let mut right_leaves = vec![addr("c"), addr("d")];
+    left_leaves.sort_unstable();
+    right_leaves.sort_unstable();
+    let left =
+      SubjectTree::canonical(left_leaves.clone(), ShardSet::singleton(0, 2))
+        .unwrap();
+    let right =
+      SubjectTree::canonical(right_leaves.clone(), ShardSet::singleton(1, 2))
+        .unwrap();
+    let joined = SubjectTree::structural(left, right);
+    for leaf in left_leaves.iter().chain(&right_leaves) {
+      let owner = usize::from(right_leaves.contains(leaf));
+      let path = joined.merkle_proof(leaf, owner).expect("member path");
+      assert!(ixon::merkle::verify_merkle_proof(&joined.root, leaf, &path));
+    }
+  }
+
+  #[test]
+  fn cache_key_has_a_stable_test_vector() {
+    let claim = vec![G::from_u64(1), G::from_u64(2), G::from_u64(3)];
+    let key = cache_key(b"vk", &[7; 40], &claim);
+    assert_eq!(
+      key.hex(),
+      "86ed059157e2915fe0a83f1afd58f31f7553659ad778669f6b795e1473e7afe0"
+    );
+  }
+
+  fn store_axiom(
+    env: &ixon::Env,
+    typ: Arc<Expr>,
+    refs: Vec<Address>,
+  ) -> Address {
+    let constant = Constant {
+      info: ConstantInfo::Axio(Axiom { is_unsafe: false, lvls: 0, typ }),
+      sharing: Vec::new(),
+      refs,
+      univs: Vec::new(),
+    };
+    let mut bytes = Vec::new();
+    constant.put(&mut bytes);
+    let address = Address::hash(&bytes);
+    env.store_const(address.clone(), constant);
+    address
+  }
+
+  fn shard(id: u32, block: Address) -> ShardInfo {
+    ShardInfo {
+      id,
+      blocks: vec![block],
+      heartbeats: 0,
+      own_size: 0,
+      foreign_blocks: Vec::new(),
+      cross_ingress: 0,
+      assumption_root: None,
+      measured_peak_bytes: 0,
+    }
+  }
+
+  #[test]
+  fn native_preparation_and_structural_fold_discharge_a_frontier() {
+    let env = ixon::Env::new();
+    let dependency = store_axiom(&env, Expr::sort(0), Vec::new());
+    let consumer = store_axiom(
+      &env,
+      Expr::reference(0, Vec::new()),
+      vec![dependency.clone()],
+    );
+    let manifest = ShardManifest {
+      num_shards: 2,
+      shards: vec![shard(0, consumer), shard(1, dependency.clone())],
+      total_cross_ingress: 0,
+      tree: Some(AggNode::Internal(
+        Box::new(AggNode::Leaf(0)),
+        Box::new(AggNode::Leaf(1)),
+      )),
+    };
+    let prepared = prepare_run(&env, &manifest).expect("native preparation");
+    let specs = build_specs(
+      &prepared,
+      3,
+      5,
+      0,
+      false,
+      b"aggregate-vk",
+      b"allowed",
+      &[0; 40],
+    )
+    .expect("native specs");
+    assert_eq!(specs.len(), 3);
+    assert!(specs[2].structural);
+    assert_eq!(specs[2].subject_count, 2);
+    assert!(specs[2].statement.assumptions.is_none());
+    let paths = structural_path_advice(
+      &specs[0].statement,
+      &specs[1].statement,
+      &specs[2].statement,
+      &prepared.owner_by_address,
+    )
+    .expect("structural paths");
+    assert_eq!(paths.len(), 1);
+    assert_eq!(paths[0].0, dependency);
+    assert_eq!(paths[0].1.first(), Some(&1));
+  }
+}
diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs
index 9adb0cd3c..0b49320c1 100644
--- a/crates/ffi/src/aiur/protocol.rs
+++ b/crates/ffi/src/aiur/protocol.rs
@@ -7,7 +7,7 @@ use std::sync::LazyLock;
 
 use lean_ffi::object::{
   ExternalClass, LeanArray, LeanBorrowed, LeanByteArray, LeanExcept,
-  LeanExternal, LeanNat, LeanOwned, LeanProd, LeanRef, LeanString,
+  LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString,
 };
 
 use crate::{
@@ -15,13 +15,14 @@ use crate::{
   lean::{
     LeanAiurCircuitShape, LeanAiurCommitmentParameters, LeanAiurExecuteResult,
     LeanAiurFriParameters, LeanAiurIOKeyInfo, LeanAiurProveEnvResult,
-    LeanAiurProveResult, LeanAiurQueryCount, LeanAiurToplevel,
+    LeanAiurProveResult, LeanAiurQueryCount, LeanAiurShardProveResult,
+    LeanAiurShardResult, LeanAiurToplevel,
   },
 };
 use aiur::{
   G,
   execute::{IOBuffer, IOKeyInfo, QueryRecord},
-  synthesis::{AiurProof, AiurSystem, CircuitShape},
+  synthesis::{AiurProof, AiurSystem, CircuitShape, GatedProve},
 };
 
 // =============================================================================
@@ -35,6 +36,14 @@ static AIUR_SYSTEM_CLASS: LazyLock<ExternalClass> =
 static IX_ENV_HANDLE_CLASS: LazyLock<ExternalClass> = LazyLock::new(
   ExternalClass::register_with_drop::<ixvm_codegen::env_handle::EnvHandle>,
 );
+/// Opaque handle on an execution's `QueryRecord`, returned inside every
+/// `ExecuteResult` so Lean can inspect queries (keys, multiplicities,
+/// virtual-gas spans, memory derefs) with its higher-level knowledge
+/// (fn names, layouts, addr→name maps). The record is the dominant RAM
+/// consumer of an execution — Lean callers should consume and drop it
+/// before starting the next heavy execution.
+static QUERY_RECORD_CLASS: LazyLock<ExternalClass> =
+  LazyLock::new(ExternalClass::register_with_drop::<QueryRecord>);
 
 // =============================================================================
 // Lean FFI functions
@@ -59,6 +68,27 @@ extern "C" fn rs_aiur_proof_of_bytes(
   LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)
 }
 
+/// `Aiur.Proof.ofBytesChecked : @& ByteArray → Except String Proof`
+///
+/// Unlike the legacy trusted-byte constructor above, this is safe at cache and
+/// network boundaries: malformed bytes become a Lean error instead of a Rust
+/// panic that aborts the process.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_of_bytes_checked(
+  byte_array: LeanByteArray<LeanBorrowed<'_>>,
+) -> LeanExcept<LeanOwned> {
+  match AiurProof::from_bytes(byte_array.as_bytes()) {
+    Ok(proof) => {
+      let lean_proof: LeanOwned =
+        LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into();
+      LeanExcept::ok(lean_proof)
+    },
+    Err(err) => {
+      LeanExcept::error_string(&format!("proof deserialization failed: {err}"))
+    },
+  }
+}
+
 /// `Aiur.AiurSystem.vkBytes : @& AiurSystem → ByteArray`
 ///
 /// Serializes the verifying key (`System<AiurCircuit>`) — see
@@ -143,6 +173,24 @@ extern "C" fn rs_aiur_system_verify(
   }
 }
 
+/// `AiurSystem.proofToAdviceBytes : @& AiurSystem → @& Array G → @& Proof → Except String ByteArray`
+///
+/// The proof re-encoded in the per-query advice transport the in-circuit
+/// verifier consumes (pruned FRI multiproofs expanded to one path per
+/// query); errors if the proof does not verify natively.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_proof_to_advice_bytes(
+  aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  claim: LeanArray<LeanBorrowed<'_>>,
+  proof_obj: LeanExternal<AiurProof, LeanBorrowed<'_>>,
+) -> LeanExcept<LeanOwned> {
+  let claim = claim.map(|x| lean_unbox_g(&x));
+  match aiur_system_obj.get().proof_to_advice_bytes(&claim, proof_obj.get()) {
+    Ok(bytes) => LeanExcept::ok(LeanByteArray::from_bytes(&bytes)),
+    Err(err) => LeanExcept::error_string(&format!("{err:?}")),
+  }
+}
+
 /// `Bytecode.Toplevel.execute`: runs execution only (no proof) and returns
 /// `Except String ExecuteResult` (see `Ix/Aiur/Semantics/BytecodeFfi.lean`).
 /// On execution failure (e.g. assertion mismatch from a typechecker
@@ -155,6 +203,7 @@ extern "C" fn rs_aiur_toplevel_execute(
   args: LeanArray<LeanBorrowed<'_>>,
   io_data_arr: LeanArray<LeanBorrowed<'_>>,
   io_map_arr: LeanArray<LeanBorrowed<'_>>,
+  profile: bool,
 ) -> LeanExcept<LeanOwned> {
   let toplevel = decode_toplevel(&toplevel);
   let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
@@ -164,6 +213,7 @@ extern "C" fn rs_aiur_toplevel_execute(
     fun_idx,
     args.map(|x| lean_unbox_g(&x)),
     &mut io_buffer,
+    profile,
   ) {
     Ok(pair) => pair,
     Err(err) => return LeanExcept::error_string(&err.to_string()),
@@ -172,7 +222,7 @@ extern "C" fn rs_aiur_toplevel_execute(
   LeanExcept::ok(build_execute_result(
     &output,
     &io_buffer,
-    &query_record,
+    query_record,
     &toplevel,
   ))
 }
@@ -190,6 +240,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm(
   args: LeanArray<LeanBorrowed<'_>>,
   io_data_arr: LeanArray<LeanBorrowed<'_>>,
   io_map_arr: LeanArray<LeanBorrowed<'_>>,
+  profile: bool,
 ) -> LeanExcept<LeanOwned> {
   let toplevel = decode_toplevel(&toplevel);
   let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
@@ -203,6 +254,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm(
       fun_idx,
       args.map(|x| lean_unbox_g(&x)),
       &mut io_buffer,
+      profile,
     ) {
       Ok(pair) => pair,
       Err(err) => return LeanExcept::error_string(&err.to_string()),
@@ -211,7 +263,7 @@ extern "C" fn rs_aiur_toplevel_execute_ixvm(
   LeanExcept::ok(build_execute_result(
     &output,
     &io_buffer,
-    &query_record,
+    query_record,
     &toplevel,
   ))
 }
@@ -325,21 +377,112 @@ fn build_query_counts_array(
 }
 
 /// Helper: build a Lean `ExecuteResult` (output, ioData, ioMap,
-/// queryCounts) — the return shape shared by every execute/check FFI.
+/// queryCounts, record) — the return shape shared by every execute/check
+/// FFI. Takes the `QueryRecord` by value: it moves into an opaque
+/// `QueryRecordHandle` (slot 4) that Lean can inspect via the
+/// `rs_aiur_qr_*` accessors and that frees when Lean drops the result.
 fn build_execute_result(
   output: &[G],
   io_buffer: &IOBuffer,
-  query_record: &QueryRecord,
+  query_record: QueryRecord,
   toplevel: &aiur::bytecode::Toplevel,
 ) -> LeanAiurExecuteResult<LeanOwned> {
   let result = LeanAiurExecuteResult::alloc(0);
   result.set_obj(0, build_g_array(output));
   result.set_obj(1, build_lean_io_data(io_buffer));
   result.set_obj(2, build_lean_io_map(io_buffer));
-  result.set_obj(3, build_query_counts_array(query_record, toplevel));
+  result.set_obj(3, build_query_counts_array(&query_record, toplevel));
+  result.set_obj(4, LeanExternal::alloc(&QUERY_RECORD_CLASS, query_record));
   result
 }
 
+// =============================================================================
+// QueryRecordHandle accessors. All borrow the handle; out-of-range
+// indices return 0 / an empty array (callers iterate within `fn_len`).
+// =============================================================================
+
+/// `QueryRecordHandle.fnLen : @& QueryRecordHandle → @& Nat → Nat` —
+/// number of query entries registered for function `idx`.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_qr_fn_len(
+  handle: LeanExternal<QueryRecord, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+) -> LeanOwned {
+  let idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let len = handle.get().function_queries.get(idx).map_or(0, |m| m.len());
+  LeanOwned::box_usize(len)
+}
+
+/// `QueryRecordHandle.fnKey : … → Array G` — input tuple of entry `i`
+/// of function `idx`.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_qr_fn_key(
+  handle: LeanExternal<QueryRecord, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  i: LeanNat<LeanBorrowed<'_>>,
+) -> LeanArray<LeanOwned> {
+  let idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let i = lean_unbox_nat_as_usize(i.inner());
+  let key = handle
+    .get()
+    .function_queries
+    .get(idx)
+    .and_then(|m| m.get_index(i).map(|(k, _)| k));
+  build_g_array(key.unwrap_or(&[]))
+}
+
+/// `QueryRecordHandle.fnMult : … → Nat` — multiplicity of entry `i`.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_qr_fn_mult(
+  handle: LeanExternal<QueryRecord, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  i: LeanNat<LeanBorrowed<'_>>,
+) -> LeanOwned {
+  let idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let i = lean_unbox_nat_as_usize(i.inner());
+  let mult = handle
+    .get()
+    .function_queries
+    .get(idx)
+    .filter(|m| i < m.len())
+    .map_or(0, |m| m.mult_at(i).as_canonical_u64());
+  LeanOwned::box_usize(usize::try_from(mult).expect("multiplicity fits usize"))
+}
+
+/// `QueryRecordHandle.fnVspan : … → Nat` — recorded virtual-gas span of
+/// entry `i` (0 unless the execution ran with `profile = true`).
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_qr_fn_vspan(
+  handle: LeanExternal<QueryRecord, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  i: LeanNat<LeanBorrowed<'_>>,
+) -> LeanOwned {
+  let idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let i = lean_unbox_nat_as_usize(i.inner());
+  let span =
+    handle.get().function_queries.get(idx).map_or(0, |m| m.vspan_at(i));
+  LeanOwned::box_usize(usize::try_from(span).expect("vspan fits usize"))
+}
+
+/// `QueryRecordHandle.memKey : … → Array G` — stored values of entry
+/// `ptr` in the `memory[size]` map: the deref of an Aiur `&[T; size]`
+/// pointer. Empty array when the channel or pointer is unbound.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_qr_mem_key(
+  handle: LeanExternal<QueryRecord, LeanBorrowed<'_>>,
+  size: LeanNat<LeanBorrowed<'_>>,
+  ptr: LeanNat<LeanBorrowed<'_>>,
+) -> LeanArray<LeanOwned> {
+  let size = lean_unbox_nat_as_usize(size.inner());
+  let ptr = lean_unbox_nat_as_usize(ptr.inner());
+  let key = handle
+    .get()
+    .memory_queries
+    .get(&size)
+    .and_then(|m| m.get_index(ptr).map(|(k, _)| k));
+  build_g_array(key.unwrap_or(&[]))
+}
+
 /// Helper: build a Lean `ProveResult` (claim, proof, ioData, ioMap).
 fn build_prove_result(
   claim: &[G],
@@ -402,7 +545,9 @@ fn decode_owned_blob(
   }
   Ok(
     bytes
-      .chunks_exact(32)
+      .as_chunks::<32>()
+      .0
+      .iter()
       .map(|c| ix_common::address::Address::from_slice(c).unwrap())
       .collect(),
   )
@@ -421,6 +566,7 @@ fn dispatch_execute(
   input: Vec<G>,
   io_buffer: &mut IOBuffer,
   use_bytecode: bool,
+  profile: bool,
 ) -> Result<(QueryRecord, Vec<G>), String> {
   // Same span name as the prove pipeline's execution phase
   // (`synthesis.rs`), so a standalone execute renders/records through the
@@ -429,11 +575,11 @@ fn dispatch_execute(
   let _g = tracing::info_span!("aiur/execute_ixvm").entered();
   if use_bytecode {
     toplevel
-      .execute(fun_idx, input, io_buffer)
+      .execute(fun_idx, input, io_buffer, profile)
       .map_err(|e| format!("execute (bytecode): {e}"))
   } else {
     ixvm_codegen::aiur_ixvm_runner::execute_ixvm(
-      toplevel, fun_idx, input, io_buffer,
+      toplevel, fun_idx, input, io_buffer, profile,
     )
     .map_err(|e| format!("execute_ixvm: {e}"))
   }
@@ -454,6 +600,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env(
   >,
   addr_bytes: LeanByteArray<LeanBorrowed<'_>>,
   use_bytecode: bool,
+  profile: bool,
 ) -> LeanExcept<LeanOwned> {
   let toplevel = decode_toplevel(&toplevel);
   let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
@@ -478,6 +625,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env(
     input,
     &mut io_buffer,
     use_bytecode,
+    profile,
   ) {
     Ok(p) => p,
     Err(e) => return LeanExcept::error_string(&e),
@@ -486,7 +634,7 @@ extern "C" fn rs_aiur_toplevel_check_addr_with_env(
   LeanExcept::ok(build_execute_result(
     &output,
     &io_buffer,
-    &query_record,
+    query_record,
     &toplevel,
   ))
 }
@@ -549,6 +697,8 @@ extern "C" fn rs_aiur_toplevel_check_addrs_with_env(
               input,
               &mut io_buffer,
               use_bytecode,
+              // No vspan meter: the batch keeps no records to read it from.
+              false,
             )
             .err(),
           };
@@ -574,6 +724,33 @@ extern "C" fn rs_aiur_toplevel_check_addrs_with_env(
   LeanExcept::ok(arr)
 }
 
+/// Decode a counted address-list blob (`Ix.Cli.CheckCmd.addrListsBlob`):
+/// per list, a 4-byte LE count followed by that many 32-byte addresses.
+/// The wire format of every partition crossing the FFI (the shard
+/// batch, the manifest emit).
+pub(crate) fn decode_addr_lists(
+  bytes: &[u8],
+) -> Result<Vec<Vec<ix_common::address::Address>>, String> {
+  let mut lists = Vec::new();
+  let mut off = 0usize;
+  while off < bytes.len() {
+    if off + 4 > bytes.len() {
+      return Err("addr lists: truncated count".into());
+    }
+    let n =
+      u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize;
+    off += 4;
+    if off + n * 32 > bytes.len() {
+      return Err("addr lists: truncated addresses".into());
+    }
+    lists.push(
+      ix_common::address::Address::unpack(&bytes[off..off + n * 32]).collect(),
+    );
+    off += n * 32;
+  }
+  Ok(lists)
+}
+
 /// Byte-weighted admission gate: a counting semaphore over estimated
 /// execution RSS, expressed with the std Mutex+Condvar construction.
 /// Bounds MEMORY in flight instead of shards in flight, so the rayon
@@ -617,7 +794,53 @@ impl RamGate {
 /// RSS): 5.7 MB owned -> ~9.6 GB and 1.4 MB -> ~5.5 GB, giving
 /// ~4 GiB + ~1000x; both terms rounded up for cross-shard spread.
 const EXEC_RSS_FIXED_BYTES: usize = 9 * (1 << 29); // 4.5 GiB
+// Two calibrations, each accurate in its own regime, combined as a MAX
+// in `exec_rss_estimate` because the per-owned-byte execution footprint
+// is env-dependent and the gate's contract is NEVER OOM:
+// - The affine fit (4.5 GiB + 1100x) measured on ISLB's small shards
+//   (1.4-5.7 MB owned; a pure ratio under-reserved them and OOM'd a
+//   128 GB box).
+// - The pure ratio (2500x, ~2300x measured + margin) validated on
+//   Mathlib's full-width 233-shard batch at +2% of estimate; the
+//   affine slope alone under-reserved Mathlib-class shards and
+//   over-admitted a 132-shard full-width batch to 486/495 GB
+//   (OOM, 2026-08-29 — the first Mathlib full-width run under the
+//   affine constant).
+// The max reproduces each fit where it was measured: small shards take
+// the affine branch (ISLB bench reservations unchanged), large shards
+// the ratio branch.
 const EXEC_RSS_PER_OWNED_BYTE: usize = 1100;
+const EXEC_RSS_RATIO_PER_OWNED_BYTE: usize = 2500;
+
+/// Per-shard execution-RSS reserve: the max of the two measured fits
+/// (see the constants above).
+fn exec_rss_estimate(owned_bytes: usize) -> usize {
+  EXEC_RSS_FIXED_BYTES
+    .saturating_add(owned_bytes.saturating_mul(EXEC_RSS_PER_OWNED_BYTE))
+    .max(owned_bytes.saturating_mul(EXEC_RSS_RATIO_PER_OWNED_BYTE))
+}
+
+/// FFI: the detected prover/execution RAM budget in bytes
+/// ([`detected_ram_budget`]: [`ix_kernel::shard::RAM_USABLE_FRAC`] of
+/// `MemAvailable`), or `0` when `/proc/meminfo` is unreadable — the caller
+/// decides whether to fail closed.
+#[unsafe(no_mangle)]
+extern "C" fn rs_aiur_detected_ram_budget()
+-> lean_ffi::object::LeanIOResult<LeanOwned> {
+  let bytes = detected_ram_budget().unwrap_or(0);
+  lean_ffi::object::LeanIOResult::ok(LeanOwned::box_u64(bytes as u64))
+}
+
+/// Detected prover/execution RAM budget:
+/// [`ix_kernel::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving
+/// the rest for the OS. `None` (no gate) when meminfo is unreadable —
+/// disabling the check beats guessing at it.
+#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)]
+#[allow(clippy::cast_sign_loss)] // MemAvailable and the fraction are positive
+fn detected_ram_budget() -> Option<usize> {
+  available_ram_bytes()
+    .map(|b| (b as f64 * ix_kernel::shard::RAM_USABLE_FRAC) as usize)
+}
 
 /// `MemAvailable` from `/proc/meminfo`, in bytes (Linux; includes
 /// reclaimable page cache). `None` if unreadable — the caller then
@@ -629,6 +852,84 @@ fn available_ram_bytes() -> Option<usize> {
   Some(kib * 1024)
 }
 
+/// Decode a `memory[32]` entry as a 32-byte address. Every limb has to be a
+/// byte: an entry whose limbs are not byte-valued is some other `&[T; 32]`
+/// the pointer aliased, not an `Addr`, so the caller skips that row rather
+/// than recording a truncated address.
+fn limbs_to_addr(limbs: &[G]) -> Option<[u8; 32]> {
+  let mut addr = [0u8; 32];
+  if limbs.len() != addr.len() {
+    return None;
+  }
+  for (byte, limb) in addr.iter_mut().zip(limbs) {
+    *byte = u8::try_from(limb.as_canonical_u64()).ok()?;
+  }
+  Some(addr)
+}
+
+/// Serialized width of one [`const_weights`] row: 32-byte address, then
+/// `vspan` and `mult` as little-endian `u64`s.
+const CONST_WEIGHT_ROW: usize = 48;
+
+/// Reduce an executed record to per-constant weights, so the record can be
+/// dropped inside the task that produced it: at env scale the records of a
+/// whole partition do not fit in RAM at once, but one 48-byte row per
+/// checked constant does.
+///
+/// Rows come from the `check_const` query map (`check_const_idx`), whose
+/// entries name the constants this shard actually checked. The address is
+/// the LAST input slot — `ci` is passed flattened by value — dereferenced
+/// through `memory[32]`. `vspan` is the constant's standalone check cost
+/// within its shard (memo hits replay the callee's recorded span):
+/// order-independent within a partition, but NOT exact across partitions —
+/// a callee owned by a foreign shard is assumed rather than replayed, so
+/// its span drops out of its callers' rows (measured: ~10% of a 360-const
+/// fixture's rows shift between a 1-shard and a 4-shard partition, a few
+/// by >2x). Schedule off a profile measured under the partition being
+/// scheduled. Unconstrained hint rows (multiplicity 0) are skipped: they
+/// are not checks.
+///
+/// Empty unless the execution ran with `profile = true`; without it every
+/// span reads 0 and the rows carry no signal.
+fn const_weights(
+  record: &QueryRecord,
+  toplevel: &aiur::bytecode::Toplevel,
+  check_const_idx: usize,
+) -> Vec<u8> {
+  let (Some(map), Some(function)) = (
+    record.function_queries.get(check_const_idx),
+    toplevel.functions.get(check_const_idx),
+  ) else {
+    return Vec::new();
+  };
+  let Some(addr_pos) = function.layout.input_size.checked_sub(1) else {
+    return Vec::new();
+  };
+  let memory = record.memory_queries.get(&32);
+  let mut rows = Vec::with_capacity(map.len() * CONST_WEIGHT_ROW);
+  for i in 0..map.len() {
+    let mult = map.mult_at(i).as_canonical_u64();
+    if mult == 0 {
+      continue;
+    }
+    let Some(ptr) = map.get_index(i).and_then(|(key, _)| key.get(addr_pos))
+    else {
+      continue;
+    };
+    let ptr = usize::try_from(ptr.as_canonical_u64()).unwrap_or(usize::MAX);
+    let Some(addr) = memory
+      .and_then(|m| m.get_index(ptr).map(|(k, _)| k))
+      .and_then(limbs_to_addr)
+    else {
+      continue;
+    };
+    rows.extend_from_slice(&addr);
+    rows.extend_from_slice(&map.vspan_at(i).to_le_bytes());
+    rows.extend_from_slice(&mult.to_le_bytes());
+  }
+  rows
+}
+
 /// `Bytecode.Toplevel.shardCheckBatchWithEnv`: check EVERY shard of a
 /// partition in one call — rayon over the shard list with true
 /// work-stealing (no chunk barriers), each shard through the exact
@@ -639,12 +940,14 @@ fn available_ram_bytes() -> Option<usize> {
 ///
 /// `shards_blob` encodes the partition as, per shard, a 4-byte LE
 /// owned-constant count followed by that many 32-byte addresses.
-/// Returns one `(error, peak_bytes)` pair PER SHARD in shard order:
+/// Returns one `(error, peak_bytes, weights)` triple PER SHARD in shard order:
 /// an empty error string means the shard checked clean, and
 /// `peak_bytes` is the analytic prover peak
 /// ([`aiur::synthesis::AiurSystem::peak_prove_bytes`]) of its executed
 /// record — the number split/merge decisions compare against a prover
-/// budget (0 when the shard failed). `jobs = 0` uses rayon's default
+/// budget (0 when the shard failed). `weights` is the shard's
+/// [`const_weights`] blob — empty unless `profile`, which also enables
+/// the per-entry virtual-gas meter the blob reads. `jobs = 0` uses rayon's default
 /// pool width (all cores) — safe at full width because admission is
 /// bounded by [`RamGate`], not by thread count; pass `jobs` only to
 /// narrow CPU use.
@@ -664,34 +967,20 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
   jobs: LeanNat<LeanBorrowed<'_>>,
   commitment_parameters: LeanAiurCommitmentParameters<LeanBorrowed<'_>>,
   fri_parameters: LeanAiurFriParameters<LeanBorrowed<'_>>,
+  profile: bool,
+  check_const_idx: LeanNat<LeanBorrowed<'_>>,
+  max_ram_bytes: LeanNat<LeanBorrowed<'_>>,
 ) -> LeanExcept<LeanOwned> {
   use rayon::prelude::*;
   let toplevel = decode_toplevel(&toplevel_obj);
   let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
   let jobs = lean_unbox_nat_as_usize(jobs.inner());
-  let mut shards: Vec<Vec<ix_common::address::Address>> = Vec::new();
-  {
-    let bytes = shards_blob.as_bytes();
-    let mut off = 0usize;
-    while off < bytes.len() {
-      if off + 4 > bytes.len() {
-        return LeanExcept::error_string("shards_blob: truncated count");
-      }
-      let n =
-        u32::from_le_bytes(bytes[off..off + 4].try_into().unwrap()) as usize;
-      off += 4;
-      if off + n * 32 > bytes.len() {
-        return LeanExcept::error_string("shards_blob: truncated addresses");
-      }
-      shards.push(
-        bytes[off..off + n * 32]
-          .chunks_exact(32)
-          .map(|c| ix_common::address::Address::from_slice(c).unwrap())
-          .collect(),
-      );
-      off += n * 32;
-    }
-  }
+  let check_const_idx = lean_unbox_nat_as_usize(check_const_idx.inner());
+  let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner());
+  let shards = match decode_addr_lists(shards_blob.as_bytes()) {
+    Ok(v) => v,
+    Err(e) => return LeanExcept::error_string(&e),
+  };
   let env = &env_handle.get().env;
   // One system build for the whole batch: the RAM model reads circuit
   // widths and lookup counts off the compiled circuits.
@@ -708,19 +997,18 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
   let estimates: Vec<usize> = shards
     .iter()
     .map(|owned| {
-      EXEC_RSS_FIXED_BYTES.saturating_add(
+      exec_rss_estimate(
         owned
           .iter()
           .filter_map(|a| env.get_const_bytes(a).map(|b| b.len()))
-          .sum::<usize>()
-          .saturating_mul(EXEC_RSS_PER_OWNED_BYTE),
+          .sum::<usize>(),
       )
     })
     .collect();
   let gate = RamGate {
     reserved: std::sync::Mutex::new(0),
     cv: std::sync::Condvar::new(),
-    budget: available_ram_bytes().map_or(usize::MAX, |b| b / 100 * 85),
+    budget: detected_ram_budget().unwrap_or(usize::MAX),
   };
   {
     let gib = 1024.0 * 1024.0 * 1024.0;
@@ -734,7 +1022,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
       max as f64 / gib,
     );
   }
-  let check_batch = || -> Vec<(String, usize)> {
+  let check_batch = || -> Vec<(String, usize, Vec<u8>, usize)> {
     shards
       .par_iter()
       .zip(estimates.par_iter())
@@ -744,17 +1032,33 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
           match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness(
             env, owned,
           ) {
-            Err(e) => (format!("witness build: {e}"), 0),
+            Err(e) => (format!("witness build: {e}"), 0, Vec::new(), 1),
             Ok((_claim, input, mut io_buffer)) => match dispatch_execute(
               &toplevel,
               fun_idx,
               input,
               &mut io_buffer,
               use_bytecode,
+              profile,
             ) {
-              Err(e) => (e, 0),
+              Err(e) => (e, 0, Vec::new(), 1),
+              // All three reductions happen here, while the record is
+              // still owned by this task: it is dropped before
+              // `gate.release`, so admission keeps bounding peak RSS by
+              // the shards in flight rather than by the whole partition.
               Ok((record, _output)) => {
-                (String::new(), system.peak_prove_bytes(&record).peak)
+                let peak = system.peak_prove_bytes(&record).peak;
+                let weights = if profile {
+                  const_weights(&record, &toplevel, check_const_idx)
+                } else {
+                  Vec::new()
+                };
+                let parts = if max_ram_bytes > 0 && peak > max_ram_bytes {
+                  system.suggested_split_parts(&record, max_ram_bytes)
+                } else {
+                  1
+                };
+                (String::new(), peak, weights, parts)
               },
             },
           };
@@ -775,9 +1079,13 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch(
     pool.install(check_batch)
   };
   let arr = LeanArray::alloc(results.len());
-  for (i, (err, peak)) in results.iter().enumerate() {
-    arr
-      .set(i, LeanProd::new(LeanString::new(err), LeanOwned::box_usize(*peak)));
+  for (i, (err, peak, weights, parts)) in results.iter().enumerate() {
+    let row = LeanAiurShardResult::alloc(0);
+    row.set_obj(0, LeanString::new(err));
+    row.set_obj(1, LeanOwned::box_usize(*peak));
+    row.set_obj(2, LeanByteArray::from_bytes(weights));
+    row.set_obj(3, LeanOwned::box_usize(*parts));
+    arr.set(i, row);
   }
   LeanExcept::ok(arr)
 }
@@ -795,6 +1103,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env(
   >,
   owned_blob: LeanByteArray<LeanBorrowed<'_>>,
   use_bytecode: bool,
+  profile: bool,
 ) -> LeanExcept<LeanOwned> {
   let toplevel = decode_toplevel(&toplevel);
   let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
@@ -823,6 +1132,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env(
     input,
     &mut io_buffer,
     use_bytecode,
+    profile,
   ) {
     Ok(p) => p,
     Err(e) => return LeanExcept::error_string(&e),
@@ -831,7 +1141,7 @@ extern "C" fn rs_aiur_toplevel_shard_check_with_env(
   LeanExcept::ok(build_execute_result(
     &output,
     &io_buffer,
-    &query_record,
+    query_record,
     &toplevel,
   ))
 }
@@ -879,7 +1189,7 @@ extern "C" fn rs_aiur_system_prove_addr_with_env(
         &input,
         &mut io_buffer,
         |toplevel, fun_idx, input, io_buffer| {
-          toplevel.execute(fun_idx, input, io_buffer)
+          toplevel.execute(fun_idx, input, io_buffer, false)
         },
       )
     } else {
@@ -887,7 +1197,12 @@ extern "C" fn rs_aiur_system_prove_addr_with_env(
         fun_idx,
         &input,
         &mut io_buffer,
-        ixvm_codegen::aiur_ixvm_runner::execute_ixvm,
+        |toplevel, fun_idx, input, io_buffer| {
+          // The prove path never profiles.
+          ixvm_codegen::aiur_ixvm_runner::execute_ixvm(
+            toplevel, fun_idx, input, io_buffer, false,
+          )
+        },
       )
     };
 
@@ -895,9 +1210,32 @@ extern "C" fn rs_aiur_system_prove_addr_with_env(
   })
 }
 
-/// `AiurSystem.shardProveWithEnv`: per-shard prove against a
-/// Rust-owned `EnvHandle`. Same `ProveEnvResult` return shape as
-/// `proveAddrWithEnv`.
+/// `AiurSystem.shardProveWithEnv`: per-shard prove against a Rust-owned
+/// `EnvHandle`, executing ONCE and proving from that record.
+///
+/// `max_ram_bytes` is a per-shard prover-RAM budget checked against the
+/// executed record's projected peak, in the gap between execution and
+/// the witness phase. `0` means "detect": 85% of `MemAvailable`, the
+/// same policy the check batch's RAM gate uses. An unreadable
+/// `/proc/meminfo` disables the check rather than guessing at it.
+///
+/// Over budget, the record is dropped and `proof` comes back as `none`
+/// with the measured `peakBytes` and `suggestedParts` — the part count
+/// the peak model projects will fit the budget
+/// ([`AiurSystem::suggested_split_parts`], measured on the record while
+/// it still exists). That is a RESULT, not an error: the caller's
+/// answer is to cut the shard into that many parts and prove those.
+/// Learning it here costs one execution instead of an OOM part-way
+/// through an FFT. `suggestedParts` is `1` whenever the prove ran.
+///
+/// `exec_only` stops after execution + measurement: `proof` is `none`
+/// either way, and `suggestedParts` is 1 exactly when the peak fits —
+/// the split loop runs on executions alone, no STARK ever starts.
+///
+/// Returns `(claimBytes, proof?, peakBytes, suggestedParts)`. The final IO buffer is
+/// deliberately NOT returned: it is the shard's whole ingested byte
+/// scope, both Lean callers discarded it, and marshalling it back is
+/// pure cost on the largest buffers in the system.
 #[unsafe(no_mangle)]
 extern "C" fn rs_aiur_system_shard_prove_with_env(
   aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
@@ -907,9 +1245,12 @@ extern "C" fn rs_aiur_system_shard_prove_with_env(
     LeanBorrowed<'_>,
   >,
   owned_blob: LeanByteArray<LeanBorrowed<'_>>,
+  max_ram_bytes: LeanNat<LeanBorrowed<'_>>,
+  exec_only: bool,
 ) -> LeanExcept<LeanOwned> {
   ffi_catch_unwind_except("AiurSystem.shardProveWithEnv", || {
     let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+    let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner());
     let owned = match decode_owned_blob(&owned_blob) {
       Ok(v) => v,
       Err(e) => return LeanExcept::error_string(&e),
@@ -926,14 +1267,45 @@ extern "C" fn rs_aiur_system_shard_prove_with_env(
         },
       };
 
-    let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm(
+    // 0 = detect. Matching the check batch's gate keeps one RAM policy in
+    // the system rather than two that can disagree.
+    let budget = if max_ram_bytes > 0 {
+      Some(max_ram_bytes)
+    } else {
+      detected_ram_budget()
+    };
+    let proved = aiur_system_obj.get().prove_ixvm_within_budget(
       fun_idx,
       &input,
       &mut io_buffer,
-      ixvm_codegen::aiur_ixvm_runner::execute_ixvm,
+      // The prove path never profiles.
+      |toplevel, fun_idx, input, io_buffer| {
+        ixvm_codegen::aiur_ixvm_runner::execute_ixvm(
+          toplevel, fun_idx, input, io_buffer, false,
+        )
+      },
+      budget,
+      exec_only,
     );
-
-    LeanExcept::ok(build_prove_env_result(&claim, proof, &io_buffer))
+    let (proof, peak, parts) = match proved {
+      GatedProve::Proved { proof, peak, .. } => (
+        LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)),
+        peak,
+        1,
+      ),
+      GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts),
+      GatedProve::Measured { peak } => (LeanOption::none(), peak, 1),
+    };
+    drop(io_buffer);
+
+    let mut claim_bytes: Vec<u8> = Vec::new();
+    claim.put(&mut claim_bytes);
+    let result = LeanAiurShardProveResult::alloc(0);
+    result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes));
+    result.set_obj(1, proof);
+    result.set_obj(2, LeanOwned::box_usize(peak));
+    result.set_obj(3, LeanOwned::box_usize(parts));
+    LeanExcept::ok(result)
   })
 }
 
@@ -959,7 +1331,12 @@ extern "C" fn rs_aiur_system_prove_ixvm(
       fun_idx,
       &args,
       &mut io_buffer,
-      ixvm_codegen::aiur_ixvm_runner::execute_ixvm,
+      // The prove path never profiles.
+      |toplevel, fun_idx, input, io_buffer| {
+        ixvm_codegen::aiur_ixvm_runner::execute_ixvm(
+          toplevel, fun_idx, input, io_buffer, false,
+        )
+      },
     );
 
     build_prove_result(&claim, proof, &io_buffer).into()
@@ -967,7 +1344,9 @@ extern "C" fn rs_aiur_system_prove_ixvm(
 }
 
 /// `Bytecode.Toplevel.executeMultiStark`: run the MultiStark recursive
-/// verifier over raw proof/vk/claims byte blobs. The IO advice buffer
+/// verifier over proof-advice/vk/claims byte blobs. The proof blob is the
+/// expanded per-query transport produced by `proof_to_advice_bytes`, not the
+/// compact persisted `Proof::to_bytes` representation. The IO advice buffer
 /// (channel 0 = proof, 1 = vk, 2 = claims, key `[0]` each) is built
 /// natively via `verifier_io_buffer` — no per-byte Lean boxing, no
 /// buffer marshalling across FFI. `use_bytecode` selects the executor:
@@ -997,7 +1376,7 @@ extern "C" fn rs_aiur_multi_stark_execute(
   // Same execution-phase span as the prove pipeline.
   let _g = tracing::info_span!("aiur/execute_multi_stark").entered();
   let result = if use_bytecode {
-    toplevel.execute(fun_idx, input, &mut io_buffer)
+    toplevel.execute(fun_idx, input, &mut io_buffer, false)
   } else {
     ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark(
       &toplevel,
@@ -1017,8 +1396,106 @@ extern "C" fn rs_aiur_multi_stark_execute(
   LeanExcept::ok(result)
 }
 
+#[allow(clippy::too_many_arguments)]
+fn build_multi_stark_join_io_buffer(
+  left_proof: &[u8],
+  right_proof: &[u8],
+  recursion_vk: &[u8],
+  left_claims: &[u8],
+  right_claims: &[u8],
+  output_claim: &[u8],
+  allowed: &[u8],
+  preimages_blob: &[u8],
+  trees_blob: &[u8],
+  paths_blob: &[u8],
+) -> Result<IOBuffer, String> {
+  use ixvm_codegen::aiur_multi_stark_runner::{
+    JoinAdvice, decode_join_paths, decode_join_preimages, decode_join_trees,
+    join_io_buffer,
+  };
+
+  let preimages = decode_join_preimages(preimages_blob)?;
+  let trees = decode_join_trees(trees_blob)?;
+  let paths = decode_join_paths(paths_blob)?;
+  Ok(join_io_buffer(&JoinAdvice {
+    proofs: [left_proof, right_proof],
+    recursion_vk,
+    child_claims: [left_claims, right_claims],
+    output_claim,
+    allowed,
+    preimages: &preimages,
+    trees: &trees,
+    paths: &paths,
+  }))
+}
+
+/// `Bytecode.Toplevel.executeMultiStarkJoin`: execute either join entrypoint over
+/// child proof-advice/claim/tree/path blobs. Each proof is expanded with
+/// `proof_to_advice_bytes` before crossing this boundary. The native builder expands the compact keyed
+/// framing directly into the circuit's seven-channel IO buffer.
+/// As with `rs_aiur_multi_stark_execute`, callers may select either generated
+/// execution or the generic bytecode interpreter.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+extern "C" fn rs_aiur_multi_stark_join_execute(
+  toplevel: LeanAiurToplevel<LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  left_proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  recursion_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  left_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  output_claim_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  allowed_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  preimages_blob: LeanByteArray<LeanBorrowed<'_>>,
+  trees_blob: LeanByteArray<LeanBorrowed<'_>>,
+  paths_blob: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanExcept<LeanOwned> {
+  let toplevel = decode_toplevel(&toplevel);
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = match build_multi_stark_join_io_buffer(
+    left_proof_bytes.as_bytes(),
+    right_proof_bytes.as_bytes(),
+    recursion_vk_bytes.as_bytes(),
+    left_claims_bytes.as_bytes(),
+    right_claims_bytes.as_bytes(),
+    output_claim_bytes.as_bytes(),
+    allowed_bytes.as_bytes(),
+    preimages_blob.as_bytes(),
+    trees_blob.as_bytes(),
+    paths_blob.as_bytes(),
+  ) {
+    Ok(io) => io,
+    Err(err) => return LeanExcept::error_string(&err),
+  };
+  let input = pub_input.map(|x| lean_unbox_g(&x));
+
+  let _g = tracing::info_span!("aiur/execute_multi_stark_join").entered();
+  let result = if use_bytecode {
+    toplevel.execute(fun_idx, input, &mut io_buffer, false)
+  } else {
+    ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark(
+      &toplevel,
+      fun_idx,
+      input,
+      &mut io_buffer,
+    )
+  };
+  let (query_record, output) = match result {
+    Ok(pair) => pair,
+    Err(err) => return LeanExcept::error_string(&err.to_string()),
+  };
+
+  let lean_query_counts = build_query_counts_array(&query_record, &toplevel);
+  LeanExcept::ok(LeanProd::new(build_g_array(&output), lean_query_counts))
+}
+
 /// `AiurSystem.proveMultiStark`: prove the MultiStark recursive
-/// verifier over raw proof/vk/claims byte blobs. Buffer construction
+/// verifier over proof-advice/vk/claims byte blobs. The proof blob is the
+/// expanded per-query transport, while `Proof::to_bytes` remains the compact
+/// storage/wire representation. Buffer construction
 /// and executor selection as in `rs_aiur_multi_stark_execute`; the
 /// prove itself reuses the executor-generic `AiurSystem::prove_ixvm`.
 /// Returns `(claim, proof)`; the final buffer is not returned.
@@ -1061,6 +1538,228 @@ extern "C" fn rs_aiur_multi_stark_prove(
   })
 }
 
+/// `AiurSystem.proveMultiStarkJoin`: prove one valid join-entrypoint execution
+/// using the same native advice builder and generated/interpreted executor
+/// selection as `rs_aiur_multi_stark_join_execute`.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+extern "C" fn rs_aiur_multi_stark_join_prove(
+  aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  left_proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_proof_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  recursion_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  left_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  output_claim_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  allowed_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  preimages_blob: LeanByteArray<LeanBorrowed<'_>>,
+  trees_blob: LeanByteArray<LeanBorrowed<'_>>,
+  paths_blob: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanExcept<LeanOwned> {
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = match build_multi_stark_join_io_buffer(
+    left_proof_bytes.as_bytes(),
+    right_proof_bytes.as_bytes(),
+    recursion_vk_bytes.as_bytes(),
+    left_claims_bytes.as_bytes(),
+    right_claims_bytes.as_bytes(),
+    output_claim_bytes.as_bytes(),
+    allowed_bytes.as_bytes(),
+    preimages_blob.as_bytes(),
+    trees_blob.as_bytes(),
+    paths_blob.as_bytes(),
+  ) {
+    Ok(io) => io,
+    Err(err) => return LeanExcept::error_string(&err),
+  };
+  let args = pub_input.map(|x| lean_unbox_g(&x));
+
+  let system = aiur_system_obj.get();
+  let (claim, proof) = if use_bytecode {
+    system.prove(fun_idx, &args, &mut io_buffer)
+  } else {
+    system.prove_ixvm(
+      fun_idx,
+      &args,
+      &mut io_buffer,
+      ixvm_codegen::aiur_multi_stark_runner::execute_multi_stark,
+    )
+  };
+
+  let lean_proof: LeanOwned =
+    LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into();
+  LeanExcept::ok(LeanProd::new(build_g_array(&claim), lean_proof))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn build_ix_aggr_io_buffer(
+  shape: usize,
+  left_proof_advice: &[u8],
+  right_proof_advice: &[u8],
+  ixvm_vk: &[u8],
+  self_vk: &[u8],
+  left_claims: &[u8],
+  right_claims: &[u8],
+  output_claim: &[u8],
+  allowed: &[u8],
+  preimages_blob: &[u8],
+  trees_blob: &[u8],
+  paths_blob: &[u8],
+) -> Result<IOBuffer, String> {
+  use ixvm_codegen::aiur_ix_aggr_runner::{
+    AggrAdvice, aggr_io_buffer, decode_aggr_paths, decode_aggr_preimages,
+    decode_aggr_trees,
+  };
+
+  let shape = u8::try_from(shape)
+    .map_err(|err| format!("aggr shape {shape} out of range: {err}"))?;
+  let preimages = decode_aggr_preimages(preimages_blob)?;
+  let trees = decode_aggr_trees(trees_blob)?;
+  let paths = decode_aggr_paths(paths_blob)?;
+  Ok(aggr_io_buffer(&AggrAdvice {
+    shape,
+    proof_advice: [left_proof_advice, right_proof_advice],
+    ixvm_vk,
+    self_vk,
+    child_claims: [left_claims, right_claims],
+    output_claim,
+    allowed,
+    preimages: &preimages,
+    trees: &trees,
+    paths: &paths,
+  }))
+}
+
+/// `Bytecode.Toplevel.executeIxAggr`: execute the `ix_aggr` entrypoint over
+/// raw proof-advice/claim/tree blobs plus the shape hint. The native builder
+/// expands the compact keyed framing directly into the circuit's
+/// seven-channel IO buffer. As with `rs_aiur_multi_stark_execute`, callers
+/// may select either generated execution or the generic bytecode
+/// interpreter.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+extern "C" fn rs_aiur_ix_aggr_execute(
+  toplevel: LeanAiurToplevel<LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  shape: LeanNat<LeanBorrowed<'_>>,
+  left_proof_advice_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_proof_advice_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  ixvm_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  self_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  left_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  output_claim_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  allowed_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  preimages_blob: LeanByteArray<LeanBorrowed<'_>>,
+  trees_blob: LeanByteArray<LeanBorrowed<'_>>,
+  paths_blob: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanExcept<LeanOwned> {
+  let toplevel = decode_toplevel(&toplevel);
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = match build_ix_aggr_io_buffer(
+    lean_unbox_nat_as_usize(shape.inner()),
+    left_proof_advice_bytes.as_bytes(),
+    right_proof_advice_bytes.as_bytes(),
+    ixvm_vk_bytes.as_bytes(),
+    self_vk_bytes.as_bytes(),
+    left_claims_bytes.as_bytes(),
+    right_claims_bytes.as_bytes(),
+    output_claim_bytes.as_bytes(),
+    allowed_bytes.as_bytes(),
+    preimages_blob.as_bytes(),
+    trees_blob.as_bytes(),
+    paths_blob.as_bytes(),
+  ) {
+    Ok(io) => io,
+    Err(err) => return LeanExcept::error_string(&err),
+  };
+  let input = pub_input.map(|x| lean_unbox_g(&x));
+
+  let _g = tracing::info_span!("aiur/execute_ix_aggr").entered();
+  let result = if use_bytecode {
+    toplevel.execute(fun_idx, input, &mut io_buffer, false)
+  } else {
+    ixvm_codegen::aiur_ix_aggr_runner::execute_ix_aggr(
+      &toplevel,
+      fun_idx,
+      input,
+      &mut io_buffer,
+    )
+  };
+  let (query_record, output) = match result {
+    Ok(pair) => pair,
+    Err(err) => return LeanExcept::error_string(&err.to_string()),
+  };
+
+  let lean_query_counts = build_query_counts_array(&query_record, &toplevel);
+  LeanExcept::ok(LeanProd::new(build_g_array(&output), lean_query_counts))
+}
+
+/// `AiurSystem.proveIxAggr`: prove one valid `ix_aggr` execution using the
+/// same native advice builder and generated/interpreted executor selection
+/// as `rs_aiur_ix_aggr_execute`.
+#[unsafe(no_mangle)]
+#[allow(clippy::too_many_arguments)]
+extern "C" fn rs_aiur_ix_aggr_prove(
+  aiur_system_obj: LeanExternal<AiurSystem, LeanBorrowed<'_>>,
+  fun_idx: LeanNat<LeanBorrowed<'_>>,
+  pub_input: LeanArray<LeanBorrowed<'_>>,
+  shape: LeanNat<LeanBorrowed<'_>>,
+  left_proof_advice_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_proof_advice_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  ixvm_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  self_vk_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  left_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  right_claims_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  output_claim_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  allowed_bytes: LeanByteArray<LeanBorrowed<'_>>,
+  preimages_blob: LeanByteArray<LeanBorrowed<'_>>,
+  trees_blob: LeanByteArray<LeanBorrowed<'_>>,
+  paths_blob: LeanByteArray<LeanBorrowed<'_>>,
+  use_bytecode: bool,
+) -> LeanExcept<LeanOwned> {
+  let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner());
+  let mut io_buffer = match build_ix_aggr_io_buffer(
+    lean_unbox_nat_as_usize(shape.inner()),
+    left_proof_advice_bytes.as_bytes(),
+    right_proof_advice_bytes.as_bytes(),
+    ixvm_vk_bytes.as_bytes(),
+    self_vk_bytes.as_bytes(),
+    left_claims_bytes.as_bytes(),
+    right_claims_bytes.as_bytes(),
+    output_claim_bytes.as_bytes(),
+    allowed_bytes.as_bytes(),
+    preimages_blob.as_bytes(),
+    trees_blob.as_bytes(),
+    paths_blob.as_bytes(),
+  ) {
+    Ok(io) => io,
+    Err(err) => return LeanExcept::error_string(&err),
+  };
+  let args = pub_input.map(|x| lean_unbox_g(&x));
+
+  let system = aiur_system_obj.get();
+  let (claim, proof) = if use_bytecode {
+    system.prove(fun_idx, &args, &mut io_buffer)
+  } else {
+    system.prove_ixvm(
+      fun_idx,
+      &args,
+      &mut io_buffer,
+      ixvm_codegen::aiur_ix_aggr_runner::execute_ix_aggr,
+    )
+  };
+
+  let lean_proof: LeanOwned =
+    LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into();
+  LeanExcept::ok(LeanProd::new(build_g_array(&claim), lean_proof))
+}
+
 // =============================================================================
 // Helpers
 // =============================================================================
diff --git a/crates/ffi/src/catalog.rs b/crates/ffi/src/catalog.rs
index 6384a5836..f62e9ceef 100644
--- a/crates/ffi/src/catalog.rs
+++ b/crates/ffi/src/catalog.rs
@@ -127,9 +127,8 @@ pub extern "C" fn rs_catalog_assemble(
       return LeanIOResult::error_string(&format!("rs_catalog_assemble: {e}"));
     },
   };
-  let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE))
-    .map(|m| m.len())
-    .unwrap_or(0);
+  let manifest_bytes =
+    std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len());
   let mut summary = catalog_json(&catalog);
   summary["bytes"] = serde_json::json!(manifest_bytes);
   summary["out"] = serde_json::json!(out_path);
@@ -196,9 +195,8 @@ pub extern "C" fn rs_catalog_info(
       return LeanIOResult::error_string(&format!("rs_catalog_info: {e}"));
     },
   };
-  let manifest_bytes = std::fs::metadata(dir.join(cat::MANIFEST_FILE))
-    .map(|m| m.len())
-    .unwrap_or(0);
+  let manifest_bytes =
+    std::fs::metadata(dir.join(cat::MANIFEST_FILE)).map_or(0, |m| m.len());
   let mut summary = catalog_json(&catalog);
   summary["bytes"] = serde_json::json!(manifest_bytes);
   LeanIOResult::ok(LeanString::new(&summary.to_string()))
diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs
index a71a167d7..5de93005a 100644
--- a/crates/ffi/src/kernel.rs
+++ b/crates/ffi/src/kernel.rs
@@ -41,8 +41,8 @@ use lean_ffi::object::LeanNat;
 use rustc_hash::FxHashMap;
 
 use lean_ffi::object::{
-  LeanArray, LeanBool, LeanBorrowed, LeanIOResult, LeanList, LeanOption,
-  LeanOwned, LeanProd, LeanRef, LeanString,
+  LeanArray, LeanBool, LeanBorrowed, LeanByteArray, LeanExternal, LeanIOResult,
+  LeanList, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString,
 };
 
 use crate::lean::LeanIxCheckError;
@@ -1293,7 +1293,7 @@ where
 fn resolve_kernel_check_workers(total: usize, quiet: bool) -> usize {
   let env_workers = std::env::var("IX_KERNEL_CHECK_WORKERS").ok();
   let no_par = std::env::var("IX_NO_PAR").ok().as_deref() == Some("1");
-  let available = thread::available_parallelism().map(|n| n.get()).unwrap_or(1);
+  let available = thread::available_parallelism().map_or(1, |n| n.get());
   resolve_kernel_check_workers_from(
     total,
     quiet,
@@ -2330,21 +2330,30 @@ fn static_block_profile(env: &IxonEnv) -> BlockProfile {
   builder.finish()
 }
 
-/// FFI: partition a `.ixe` into `num_shards` shards with the STATIC
-/// strategy — no out-of-circuit profiling run. Builds the static block
-/// profile ([`static_block_profile`]), byte-balanced min-cut over the
-/// walk-edge nets, then the predicted-cost rebalance post-pass
+/// FFI: partition a `.ixe` with the STATIC strategy — no out-of-circuit
+/// profiling run. An explicit nonzero `num_shards` fixes the count. Otherwise,
+/// `ram_gib` seeds it from the static block-shape score after the profile is
+/// loaded ([`ix_kernel::shard::static_seed_shards`]). Builds the static block
+/// profile ([`static_block_profile`]), byte-balanced min-cut over the walk-edge
+/// nets, then the predicted-cost rebalance post-pass
 /// (`ix_kernel::shard::shard_static`). Writes a `.ixes` manifest.
 #[allow(clippy::cast_precision_loss)] // balance_pct is a small percentage
 #[unsafe(no_mangle)]
 pub extern "C" fn rs_shard_env_static(
   env_path: LeanString<LeanBorrowed<'_>>,
   num_shards: LeanString<LeanBorrowed<'_>>,
+  ram_gib: LeanString<LeanBorrowed<'_>>,
   balance_pct: LeanString<LeanBorrowed<'_>>,
   out_path: LeanString<LeanBorrowed<'_>>,
 ) -> LeanIOResult<LeanOwned> {
   let path = env_path.to_string();
-  let num_shards = num_shards.to_string().parse::<usize>().unwrap_or(1);
+  let requested_shards = num_shards.to_string().parse::<usize>().unwrap_or(0);
+  let ram_gib = ram_gib.to_string().parse::<u64>().unwrap_or(0);
+  if requested_shards == 0 && ram_gib == 0 {
+    return LeanIOResult::error_string(
+      "rs_shard_env_static: pass a positive shard count or RAM budget",
+    );
+  }
   let balance =
     (balance_pct.to_string().parse::<u64>().unwrap_or(5) as f64) / 100.0;
   let out = out_path.to_string();
@@ -2368,6 +2377,21 @@ pub extern "C" fn rs_shard_env_static(
     profile.num_blocks(),
     profile.num_edges()
   );
+  let num_shards = if requested_shards > 0 {
+    requested_shards
+  } else {
+    let score = ix_kernel::shard::static_env_score(&profile);
+    let n = ix_kernel::shard::static_seed_shards(&profile, ram_gib);
+    eprintln!(
+      "[shard] static seed: score={score:.3e}; round({} x (score/{:.3e})^{:.2} x ({}/{ram_gib})^{:.2}) -> {n} shard(s) (heuristic; gated execution corrects every boundary)",
+      ix_kernel::shard::STATIC_SEED_REFERENCE_SHARDS,
+      ix_kernel::shard::STATIC_SEED_REFERENCE_SCORE,
+      ix_kernel::shard::STATIC_SEED_SCORE_EXPONENT,
+      ix_kernel::shard::STATIC_SEED_REFERENCE_RAM_GIB,
+      ix_kernel::shard::STATIC_SEED_BUDGET_EXPONENT,
+    );
+    n
+  };
   match ix_kernel::shard::shard_static(&profile, num_shards, balance, out_opt) {
     Ok(report) => {
       eprintln!("[rs_shard_static]\n{report}");
@@ -2377,6 +2401,226 @@ pub extern "C" fn rs_shard_env_static(
   }
 }
 
+/// FFI: write a `.ixes` manifest describing an EXPLICIT partition — the
+/// block lists a prove run actually produced (splits included), so the
+/// emitted manifest is the one `ix verify --ixes` can check the run's
+/// proofs against, and the one that seeds the next run with a
+/// partition that already fits.
+///
+/// `shards_blob` encodes, per shard, a 4-byte LE block count followed
+/// by that many 32-byte block addresses. Every profile block must
+/// appear in EXACTLY one shard: a prove partition covers the env by
+/// construction (splits partition their parent), so a gap or duplicate
+/// here is an input error, not a policy choice.
+///
+/// `peaks_blob`: one 8-byte LE measured prover peak per shard in shard
+/// order — the run's `peak_prove_bytes` measurements, recorded on each
+/// manifest shard for schedulers to bin-pack on.
+///
+/// Takes the caller's live `EnvHandle`: both call sites hold one for
+/// this env already, so the emit costs a profile build, not an env
+/// re-parse.
+#[allow(clippy::cast_possible_truncation)] // block/shard ids are u32 by construction
+#[unsafe(no_mangle)]
+pub extern "C" fn rs_shard_manifest_from_partition(
+  env_handle: LeanExternal<
+    ixvm_codegen::env_handle::EnvHandle,
+    LeanBorrowed<'_>,
+  >,
+  shards_blob: LeanByteArray<LeanBorrowed<'_>>,
+  peaks_blob: LeanByteArray<LeanBorrowed<'_>>,
+  out_path: LeanString<LeanBorrowed<'_>>,
+) -> LeanIOResult<LeanOwned> {
+  let out = out_path.to_string();
+  let profile = static_block_profile(&env_handle.get().env);
+  let block_id: FxHashMap<Address, u32> = profile
+    .blocks()
+    .iter()
+    .enumerate()
+    .map(|(i, b)| (b.addr.clone(), i as u32))
+    .collect();
+  let lists =
+    match crate::aiur::protocol::decode_addr_lists(shards_blob.as_bytes()) {
+      Ok(v) => v,
+      Err(e) => return LeanIOResult::error_string(&e),
+    };
+  let num_shards = lists.len();
+  let mut shard_of = vec![u32::MAX; profile.num_blocks()];
+  for (k, list) in lists.iter().enumerate() {
+    for addr in list {
+      let Some(&b) = block_id.get(addr) else {
+        return LeanIOResult::error_string(&format!(
+          "shard {k}: block {} not in the env's block profile",
+          addr.hex()
+        ));
+      };
+      if shard_of[b as usize] != u32::MAX {
+        return LeanIOResult::error_string(&format!(
+          "block {} appears in shards {} and {k}",
+          addr.hex(),
+          shard_of[b as usize]
+        ));
+      }
+      shard_of[b as usize] = k as u32;
+    }
+  }
+  let uncovered = shard_of.iter().filter(|&&s| s == u32::MAX).count();
+  if uncovered > 0 {
+    return LeanIOResult::error_string(&format!(
+      "partition covers {} of {} blocks ({uncovered} missing)",
+      profile.num_blocks() - uncovered,
+      profile.num_blocks()
+    ));
+  }
+  let peaks: Vec<u64> = peaks_blob
+    .as_bytes()
+    .as_chunks::<8>()
+    .0
+    .iter()
+    .map(|c| u64::from_le_bytes(*c))
+    .collect();
+  match ix_kernel::shard::shard_manifest_explicit(
+    &profile, &shard_of, num_shards, &peaks, &out,
+  ) {
+    Ok(summary) => {
+      eprintln!("[shard-manifest] {out}: {summary}");
+      LeanIOResult::ok(LeanOwned::box_usize(0))
+    },
+    Err(e) => LeanIOResult::error_string(&format!(
+      "rs_shard_manifest_from_partition: {e}"
+    )),
+  }
+}
+
+/// Decode `rs_shard_manifest_refine`'s refinements blob: `count(u32)`, then
+/// per refined leaf `id(u32) ‖ nparts(u32)` and per part
+/// `nblocks(u32) ‖ 32·nblocks ‖ peak(u64)`.
+fn decode_refinements(
+  bytes: &[u8],
+) -> Result<Vec<ix_kernel::shard::LeafRefinement>, String> {
+  struct Cur<'a> {
+    b: &'a [u8],
+    p: usize,
+  }
+  impl<'a> Cur<'a> {
+    fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
+      let end = self
+        .p
+        .checked_add(n)
+        .filter(|&end| end <= self.b.len())
+        .ok_or("refinements blob: truncated")?;
+      let s = &self.b[self.p..end];
+      self.p = end;
+      Ok(s)
+    }
+    fn u32(&mut self) -> Result<usize, String> {
+      Ok(u32::from_le_bytes(self.take(4)?.try_into().unwrap()) as usize)
+    }
+    fn u64(&mut self) -> Result<u64, String> {
+      Ok(u64::from_le_bytes(self.take(8)?.try_into().unwrap()))
+    }
+  }
+  let mut c = Cur { b: bytes, p: 0 };
+  let count = c.u32()?;
+  let mut out = Vec::with_capacity(count);
+  for _ in 0..count {
+    let id = u32::try_from(c.u32()?)
+      .map_err(|e| format!("refinements blob: bad id: {e}"))?;
+    let nparts = c.u32()?;
+    let mut parts = Vec::with_capacity(nparts);
+    let mut part_peaks = Vec::with_capacity(nparts);
+    for _ in 0..nparts {
+      let nblocks = c.u32()?;
+      let raw = c.take(nblocks * 32)?;
+      parts.push(
+        raw
+          .as_chunks::<32>()
+          .0
+          .iter()
+          .map(|chunk| Address::from_slice(chunk).unwrap())
+          .collect(),
+      );
+      part_peaks.push(c.u64()?);
+    }
+    out.push(ix_kernel::shard::LeafRefinement { id, parts, part_peaks });
+  }
+  if c.p != bytes.len() {
+    return Err("refinements blob: trailing bytes".into());
+  }
+  Ok(out)
+}
+
+/// FFI: refine an existing `.ixes` manifest by cutting some of its leaves
+/// into parts (`ShardManifest::refine`): every other leaf keeps its block
+/// list, record, id and place in the aggregation tree; a refined leaf's
+/// place becomes a balanced subtree over its parts, part 0 keeping the
+/// leaf's id and later parts taking fresh ids after the last existing one.
+/// `measured_blob` is empty or one `u64` analytic prover peak per SOURCE
+/// shard in id order (nonzero overrides the peak carried forward for an
+/// unsplit leaf). The new partition is validated as an exact, disjoint
+/// cover of the env's block profile; the manifest summary goes to stderr.
+/// Returns the parts' new ids: `count(u32)`, then per refinement
+/// `n(u32) ‖ n × id(u32)`.
+#[allow(clippy::cast_possible_truncation)] // ids and counts are u32 by construction
+#[unsafe(no_mangle)]
+pub extern "C" fn rs_shard_manifest_refine(
+  env_handle: LeanExternal<
+    ixvm_codegen::env_handle::EnvHandle,
+    LeanBorrowed<'_>,
+  >,
+  source_path: LeanString<LeanBorrowed<'_>>,
+  refinements_blob: LeanByteArray<LeanBorrowed<'_>>,
+  measured_blob: LeanByteArray<LeanBorrowed<'_>>,
+  out_path: LeanString<LeanBorrowed<'_>>,
+) -> LeanIOResult<LeanOwned> {
+  let source_path = source_path.to_string();
+  let out = out_path.to_string();
+  let fail = |e: String| {
+    LeanIOResult::error_string(&format!("rs_shard_manifest_refine: {e}"))
+  };
+  let source = match std::fs::read(&source_path)
+    .map_err(|e| format!("read {source_path}: {e}"))
+    .and_then(|bytes| ix_kernel::shard::ShardManifest::from_bytes(&bytes))
+  {
+    Ok(m) => m,
+    Err(e) => return fail(e),
+  };
+  let refinements = match decode_refinements(refinements_blob.as_bytes()) {
+    Ok(r) => r,
+    Err(e) => return fail(e),
+  };
+  let measured: Vec<u64> = measured_blob
+    .as_bytes()
+    .as_chunks::<8>()
+    .0
+    .iter()
+    .map(|c| u64::from_le_bytes(*c))
+    .collect();
+  let profile = static_block_profile(&env_handle.get().env);
+  match ix_kernel::shard::shard_manifest_refine(
+    &profile,
+    &source,
+    &refinements,
+    &measured,
+    &out,
+  ) {
+    Ok((summary, part_ids)) => {
+      eprintln!("[shard-refine] {out}: {summary}");
+      let mut bytes = Vec::new();
+      bytes.extend_from_slice(&(part_ids.len() as u32).to_le_bytes());
+      for ids in &part_ids {
+        bytes.extend_from_slice(&(ids.len() as u32).to_le_bytes());
+        for id in ids {
+          bytes.extend_from_slice(&id.to_le_bytes());
+        }
+      }
+      let ids: LeanOwned = LeanByteArray::from_bytes(&bytes).into();
+      LeanIOResult::ok(ids)
+    },
+    Err(e) => fail(e),
+  }
+}
+
 /// FFI: dump the static block-level reference graph of a `.ixe` as text —
 /// `block <hex> <bytes> <consts>` per ingress unit (a Muts block or a
 /// standalone constant) and `edge <consumer> <producer>` per deduped
diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs
index 44c6fd437..58e574d2f 100644
--- a/crates/ffi/src/lean.rs
+++ b/crates/ffi/src/lean.rs
@@ -288,12 +288,16 @@ lean_ffi::lean_inductive! {
   // mainWidth, stage2Width, quotientDegree, preprocessedWidth,
   // preprocessedHeight
   LeanAiurCircuitShape   [ { num_obj: 5 } ];
-  // output, ioData, ioMap, queryCounts
-  LeanAiurExecuteResult  [ { num_obj: 4 } ];
+  // output, ioData, ioMap, queryCounts, record (QueryRecordHandle)
+  LeanAiurExecuteResult  [ { num_obj: 5 } ];
   // claim, proof, ioData, ioMap
   LeanAiurProveResult    [ { num_obj: 4 } ];
   // claimBytes, proof, ioData, ioMap
   LeanAiurProveEnvResult [ { num_obj: 4 } ];
+  // error, peakBytes, weights, suggestedParts
+  LeanAiurShardResult    [ { num_obj: 4 } ];
+  // claimBytes, proof, peakBytes, suggestedParts
+  LeanAiurShardProveResult [ { num_obj: 4 } ];
 
   // --- Block / comparison types ---
 
diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs
index b4154436d..baded47da 100644
--- a/crates/ffi/src/lean_env.rs
+++ b/crates/ffi/src/lean_env.rs
@@ -4359,7 +4359,7 @@ fn analyze_const_size(stt: &ix_compile::compile::CompileState, name_str: &str) {
   }
 
   // Sort by total size descending
-  dep_breakdowns.sort_by(|a, b| b.1.total().cmp(&a.1.total()));
+  dep_breakdowns.sort_by_key(|(_, b)| std::cmp::Reverse(b.total()));
 
   let total_deps_alpha: usize =
     dep_breakdowns.iter().map(|(_, b)| b.alpha_size).sum();
@@ -4563,7 +4563,7 @@ fn analyze_block_size_stats(stt: &ix_compile::compile::CompileState) {
     .collect();
 
   // Sort by overhead descending (most bloated first)
-  overheads.sort_by(|a, b| b.1.cmp(&a.1));
+  overheads.sort_by_key(|o| std::cmp::Reverse(o.1));
 
   // Compute statistics
   let avg_ratio = if total_hash_consed > 0 {
diff --git a/crates/ffi/src/lean_ixon/sharing.rs b/crates/ffi/src/lean_ixon/sharing.rs
index 9811fb63d..9905fc331 100644
--- a/crates/ffi/src/lean_ixon/sharing.rs
+++ b/crates/ffi/src/lean_ixon/sharing.rs
@@ -36,7 +36,7 @@ pub extern "C" fn rs_debug_sharing_analysis(
     .collect();
 
   // Sort by usage count descending
-  candidates.sort_by(|a, b| b.1.usage_count.cmp(&a.1.usage_count));
+  candidates.sort_by_key(|c| std::cmp::Reverse(c.1.usage_count));
 
   println!("[Rust] Subterms with usage >= 2:");
   for (hash, info, eff_size) in candidates {
diff --git a/crates/ixon/src/diff.rs b/crates/ixon/src/diff.rs
index 788aa0585..cd8c9a491 100644
--- a/crates/ixon/src/diff.rs
+++ b/crates/ixon/src/diff.rs
@@ -2537,7 +2537,7 @@ mod tests {
     let index = Env::parse_lazy_index(&bytes).expect("lazy index");
     let mut sizes: Vec<(usize, Address)> =
       index.consts.iter().map(|c| (c.len, c.addr.clone())).collect();
-    sizes.sort_by(|a, b| b.0.cmp(&a.0));
+    sizes.sort_by_key(|(l, _)| std::cmp::Reverse(*l));
     let total: usize = sizes.iter().map(|(l, _)| *l).sum();
     println!("consts: {} total bytes: {}", sizes.len(), total);
     for (len, addr) in sizes.iter().take(top) {
diff --git a/crates/ixon/src/proof.rs b/crates/ixon/src/proof.rs
index c43846d60..efe3cc9d3 100644
--- a/crates/ixon/src/proof.rs
+++ b/crates/ixon/src/proof.rs
@@ -144,10 +144,10 @@ pub enum RevealConstantInfo {
 ///   circuit to resolve a leaf from a conditional claim's assumption
 ///   set. Carries no assumptions itself.
 ///
-/// The `assumptions` root may be any merkle tree (canonical sorted+
-/// padded via `merkle_root_canonical`, or free-form via `merkle_join`)
-/// with `Address` leaves. Verifiers recover the leaf set via the
-/// `AssumptionTree` serialization when free-form.
+/// Merkle commitments carried by claims — both `CheckEnv.root` and every
+/// `assumptions` root — may be canonical sorted+padded trees from
+/// `merkle_root_canonical` or free-form trees from `merkle_join`. Verifiers
+/// recover leaves or membership evidence according to the proof protocol.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Claim {
   /// `input` evaluates to `output`, optionally modulo `assumptions`.
@@ -1177,6 +1177,7 @@ impl Proof {
 #[cfg(test)]
 mod tests {
   use super::*;
+  use crate::merkle::{merkle_join, merkle_root_canonical};
   use quickcheck::{Arbitrary, Gen};
   use quickcheck_macros::quickcheck;
 
@@ -1573,6 +1574,18 @@ mod tests {
     assert!(claim_roundtrip(&claim));
   }
 
+  #[test]
+  fn test_check_env_claim_accepts_structural_root() {
+    let a = Address::hash(b"structural-a");
+    let b = Address::hash(b"structural-b");
+    let c = Address::hash(b"structural-c");
+    let left = merkle_root_canonical(&[a.clone(), b.clone()]).unwrap();
+    let right = merkle_root_canonical(std::slice::from_ref(&c)).unwrap();
+    let root = merkle_join(&left, &right);
+    assert_ne!(root, merkle_root_canonical(&[a, b, c]).unwrap());
+    assert!(claim_roundtrip(&Claim::CheckEnv { root, assumptions: None }));
+  }
+
   #[test]
   fn test_contains_claim_roundtrip() {
     let claim = Claim::Contains {
diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs
new file mode 100644
index 000000000..75c02f10d
--- /dev/null
+++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs
@@ -0,0 +1,27039 @@
+// Auto-generated by Aiur codegen. Do not edit.
+//
+// Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly.
+//
+// Skip rustfmt — this file is huge and the codegen lays it out
+// for the compiler, not for humans.
+#![cfg_attr(rustfmt, rustfmt::skip)]
+#![allow(
+  unused_variables, unused_assignments, unused_mut, dead_code,
+  unused_parens, non_snake_case, clippy::all,
+  clippy::ptr_as_ptr, clippy::match_same_arms,
+  clippy::large_types_passed_by_value,
+)]
+
+use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
+use aiur::G;
+use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
+
+const INPUT_SIZE_0: usize = 2;
+const IN_0: usize = 2;
+const OUT_0: usize = 1;
+fn aiur_fn_0(
+  inp: [G; IN_0],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_0], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 };
+    let __ret: [G; OUT_0] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_1: usize = 2;
+const IN_1: usize = 2;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = G::from_u64(256);
+    let __v_67: G = (__v_9 * __v_66);
+    let __v_68: G = (__v_67 + __v_8);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_70 + __v_7);
+    let __v_72: G = G::from_u64(256);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_73 + __v_6);
+    let __v_75: G = G::from_u64(256);
+    let __v_76: G = (__v_74 * __v_75);
+    let __v_77: G = (__v_76 + __v_5);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_77 * __v_78);
+    let __v_80: G = (__v_79 + __v_4);
+    let __v_81: G = G::from_u64(256);
+    let __v_82: G = (__v_80 * __v_81);
+    let __v_83: G = (__v_82 + __v_3);
+    let __v_84: G = G::from_u64(256);
+    let __v_85: G = (__v_41 * __v_84);
+    let __v_86: G = (__v_85 + __v_40);
+    let __v_87: G = G::from_u64(256);
+    let __v_88: G = (__v_86 * __v_87);
+    let __v_89: G = (__v_88 + __v_39);
+    let __v_90: G = G::from_u64(256);
+    let __v_91: G = (__v_89 * __v_90);
+    let __v_92: G = (__v_91 + __v_38);
+    let __v_93: G = G::from_u64(256);
+    let __v_94: G = (__v_92 * __v_93);
+    let __v_95: G = (__v_94 + __v_37);
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_95 * __v_96);
+    let __v_98: G = (__v_97 + __v_36);
+    let __v_99: G = G::from_u64(256);
+    let __v_100: G = (__v_98 * __v_99);
+    let __v_101: G = (__v_100 + __v_35);
+    let __v_102: G = (__v_83 - __v_101);
+    match __v_102.as_canonical_u64() {
+      0u64 => {
+        let __v_103: G = G::from_u64(256);
+        let __v_104: G = (__v_16 * __v_103);
+        let __v_105: G = (__v_104 + __v_15);
+        let __v_106: G = G::from_u64(256);
+        let __v_107: G = (__v_105 * __v_106);
+        let __v_108: G = (__v_107 + __v_14);
+        let __v_109: G = G::from_u64(256);
+        let __v_110: G = (__v_108 * __v_109);
+        let __v_111: G = (__v_110 + __v_13);
+        let __v_112: G = G::from_u64(256);
+        let __v_113: G = (__v_111 * __v_112);
+        let __v_114: G = (__v_113 + __v_12);
+        let __v_115: G = G::from_u64(256);
+        let __v_116: G = (__v_114 * __v_115);
+        let __v_117: G = (__v_116 + __v_11);
+        let __v_118: G = G::from_u64(256);
+        let __v_119: G = (__v_117 * __v_118);
+        let __v_120: G = (__v_119 + __v_10);
+        let __v_121: G = G::from_u64(256);
+        let __v_122: G = (__v_48 * __v_121);
+        let __v_123: G = (__v_122 + __v_47);
+        let __v_124: G = G::from_u64(256);
+        let __v_125: G = (__v_123 * __v_124);
+        let __v_126: G = (__v_125 + __v_46);
+        let __v_127: G = G::from_u64(256);
+        let __v_128: G = (__v_126 * __v_127);
+        let __v_129: G = (__v_128 + __v_45);
+        let __v_130: G = G::from_u64(256);
+        let __v_131: G = (__v_129 * __v_130);
+        let __v_132: G = (__v_131 + __v_44);
+        let __v_133: G = G::from_u64(256);
+        let __v_134: G = (__v_132 * __v_133);
+        let __v_135: G = (__v_134 + __v_43);
+        let __v_136: G = G::from_u64(256);
+        let __v_137: G = (__v_135 * __v_136);
+        let __v_138: G = (__v_137 + __v_42);
+        let __v_139: G = (__v_120 - __v_138);
+        match __v_139.as_canonical_u64() {
+          0u64 => {
+            let __v_140: G = G::from_u64(256);
+            let __v_141: G = (__v_23 * __v_140);
+            let __v_142: G = (__v_141 + __v_22);
+            let __v_143: G = G::from_u64(256);
+            let __v_144: G = (__v_142 * __v_143);
+            let __v_145: G = (__v_144 + __v_21);
+            let __v_146: G = G::from_u64(256);
+            let __v_147: G = (__v_145 * __v_146);
+            let __v_148: G = (__v_147 + __v_20);
+            let __v_149: G = G::from_u64(256);
+            let __v_150: G = (__v_148 * __v_149);
+            let __v_151: G = (__v_150 + __v_19);
+            let __v_152: G = G::from_u64(256);
+            let __v_153: G = (__v_151 * __v_152);
+            let __v_154: G = (__v_153 + __v_18);
+            let __v_155: G = G::from_u64(256);
+            let __v_156: G = (__v_154 * __v_155);
+            let __v_157: G = (__v_156 + __v_17);
+            let __v_158: G = G::from_u64(256);
+            let __v_159: G = (__v_55 * __v_158);
+            let __v_160: G = (__v_159 + __v_54);
+            let __v_161: G = G::from_u64(256);
+            let __v_162: G = (__v_160 * __v_161);
+            let __v_163: G = (__v_162 + __v_53);
+            let __v_164: G = G::from_u64(256);
+            let __v_165: G = (__v_163 * __v_164);
+            let __v_166: G = (__v_165 + __v_52);
+            let __v_167: G = G::from_u64(256);
+            let __v_168: G = (__v_166 * __v_167);
+            let __v_169: G = (__v_168 + __v_51);
+            let __v_170: G = G::from_u64(256);
+            let __v_171: G = (__v_169 * __v_170);
+            let __v_172: G = (__v_171 + __v_50);
+            let __v_173: G = G::from_u64(256);
+            let __v_174: G = (__v_172 * __v_173);
+            let __v_175: G = (__v_174 + __v_49);
+            let __v_176: G = (__v_157 - __v_175);
+            match __v_176.as_canonical_u64() {
+              0u64 => {
+                let __v_177: G = G::from_u64(256);
+                let __v_178: G = (__v_30 * __v_177);
+                let __v_179: G = (__v_178 + __v_29);
+                let __v_180: G = G::from_u64(256);
+                let __v_181: G = (__v_179 * __v_180);
+                let __v_182: G = (__v_181 + __v_28);
+                let __v_183: G = G::from_u64(256);
+                let __v_184: G = (__v_182 * __v_183);
+                let __v_185: G = (__v_184 + __v_27);
+                let __v_186: G = G::from_u64(256);
+                let __v_187: G = (__v_185 * __v_186);
+                let __v_188: G = (__v_187 + __v_26);
+                let __v_189: G = G::from_u64(256);
+                let __v_190: G = (__v_188 * __v_189);
+                let __v_191: G = (__v_190 + __v_25);
+                let __v_192: G = G::from_u64(256);
+                let __v_193: G = (__v_191 * __v_192);
+                let __v_194: G = (__v_193 + __v_24);
+                let __v_195: G = G::from_u64(256);
+                let __v_196: G = (__v_62 * __v_195);
+                let __v_197: G = (__v_196 + __v_61);
+                let __v_198: G = G::from_u64(256);
+                let __v_199: G = (__v_197 * __v_198);
+                let __v_200: G = (__v_199 + __v_60);
+                let __v_201: G = G::from_u64(256);
+                let __v_202: G = (__v_200 * __v_201);
+                let __v_203: G = (__v_202 + __v_59);
+                let __v_204: G = G::from_u64(256);
+                let __v_205: G = (__v_203 * __v_204);
+                let __v_206: G = (__v_205 + __v_58);
+                let __v_207: G = G::from_u64(256);
+                let __v_208: G = (__v_206 * __v_207);
+                let __v_209: G = (__v_208 + __v_57);
+                let __v_210: G = G::from_u64(256);
+                let __v_211: G = (__v_209 * __v_210);
+                let __v_212: G = (__v_211 + __v_56);
+                let __v_213: G = (__v_194 - __v_212);
+                match __v_213.as_canonical_u64() {
+                  0u64 => {
+                    let __v_214: G = G::from_u64(256);
+                    let __v_215: G = (__v_33 * __v_214);
+                    let __v_216: G = (__v_215 + __v_32);
+                    let __v_217: G = G::from_u64(256);
+                    let __v_218: G = (__v_216 * __v_217);
+                    let __v_219: G = (__v_218 + __v_31);
+                    let __v_220: G = G::from_u64(256);
+                    let __v_221: G = (__v_65 * __v_220);
+                    let __v_222: G = (__v_221 + __v_64);
+                    let __v_223: G = G::from_u64(256);
+                    let __v_224: G = (__v_222 * __v_223);
+                    let __v_225: G = (__v_224 + __v_63);
+                    let __v_226: G = (__v_219 - __v_225);
+                    match __v_226.as_canonical_u64() {
+                      0u64 => {
+                        let __v_227: G = G::from_u64(1);
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_227: G = G::from_u64(0);
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_214: G = G::from_u64(0);
+                    let __ret: [G; OUT_1] = [__v_214];
+                    if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_177: G = G::from_u64(0);
+                let __ret: [G; OUT_1] = [__v_177];
+                if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_140: G = G::from_u64(0);
+            let __ret: [G; OUT_1] = [__v_140];
+            if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_103: G = G::from_u64(0);
+        let __ret: [G; OUT_1] = [__v_103];
+        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_2: usize = 2;
+const IN_2: usize = 2;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_2], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = (__v_2 - __v_34);
+    match __v_66.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_67: G = __r_arr[0];
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_67: G = G::from_u64(0);
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_3: usize = 3;
+const IN_3: usize = 3;
+const OUT_3: usize = 1;
+fn aiur_fn_3(
+  inp: [G; IN_3],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_3], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = (__v_1 + __v_3);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_2 - __v_5);
+        let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+        let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
+        let __v_8: G = __io_read[0];
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_4: usize = 8;
+const IN_4: usize = 8;
+const OUT_4: usize = 1;
+fn aiur_fn_4(
+  inp: [G; IN_4],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_4], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            match __v_2.as_canonical_u64() {
+              0u64 => {
+                match __v_3.as_canonical_u64() {
+                  0u64 => {
+                    match __v_4.as_canonical_u64() {
+                      0u64 => {
+                        match __v_5.as_canonical_u64() {
+                          0u64 => {
+                            match __v_6.as_canonical_u64() {
+                              0u64 => {
+                                match __v_7.as_canonical_u64() {
+                                  0u64 => {
+                                    let __v_8: G = G::from_u64(1);
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_8: G = G::from_u64(0);
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_8: G = G::from_u64(0);
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_8: G = G::from_u64(0);
+                            let __ret: [G; OUT_4] = [__v_8];
+                            if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_8: G = G::from_u64(0);
+                        let __ret: [G; OUT_4] = [__v_8];
+                        if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_8: G = G::from_u64(0);
+                    let __ret: [G; OUT_4] = [__v_8];
+                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_8: G = G::from_u64(0);
+                let __ret: [G; OUT_4] = [__v_8];
+                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __ret: [G; OUT_4] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_4] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_5: usize = 8;
+const IN_5: usize = 8;
+const OUT_5: usize = 4;
+fn aiur_fn_5(
+  inp: [G; IN_5],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_5], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_8: G = G::from_u8(__u32_bytes[0]);
+    let __v_9: G = G::from_u8(__u32_bytes[1]);
+    let __v_10: G = G::from_u8(__u32_bytes[2]);
+    let __v_11: G = G::from_u8(__u32_bytes[3]);
+    let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_13: G = (__v_12 * __v_12);
+    if (__v_13 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_6: usize = 12;
+const IN_6: usize = 12;
+const OUT_6: usize = 4;
+fn aiur_fn_6(
+  inp: [G; IN_6],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_6], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_12: G = G::from_u8(__u32_bytes[0]);
+    let __v_13: G = G::from_u8(__u32_bytes[1]);
+    let __v_14: G = G::from_u8(__u32_bytes[2]);
+    let __v_15: G = G::from_u8(__u32_bytes[3]);
+    let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_14; let __vj = __v_15; 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_17: G = G::from_u64(1);
+    let __v_18: G = (__v_16 - __v_17);
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = (__v_16 - __v_19);
+    let __v_21: G = (__v_18 * __v_20);
+    let __v_22: G = (__v_16 * __v_21);
+    let __v_23: G = G::from_u64(0);
+    if (__v_22 != __v_23) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[6].weight(); } record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_7: usize = 8;
+const IN_7: usize = 8;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_7], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) };
+    let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
+    let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
+    let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
+    let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[7].weight(); } record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_8: usize = 4;
+const IN_8: usize = 4;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_8], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1];
+    if !unconstrained { record.virt += record.function_queries[8].weight(); } record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_9: usize = 4;
+const IN_9: usize = 4;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_9], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0];
+    if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_10: usize = 8;
+const IN_10: usize = 8;
+const OUT_10: usize = 4;
+fn aiur_fn_10(
+  inp: [G; IN_10],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_10], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record) };
+    let __v_8: G = __b2_out.0;
+    let __v_9: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record) };
+    let __v_10: G = __b2_out.0;
+    let __v_11: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record) };
+    let __v_12: G = __b2_out.0;
+    let __v_13: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record) };
+    let __v_14: G = __b2_out.0;
+    let __v_15: G = __b2_out.1;
+    let __v_16: G = (__v_8 + __v_11);
+    let __v_17: G = (__v_10 + __v_13);
+    let __v_18: G = (__v_12 + __v_15);
+    let __v_19: G = (__v_14 + __v_9);
+    let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[10].weight(); } record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 4;
+fn aiur_fn_11(
+  inp: [G; IN_11],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_11], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record) };
+    let __v_8: G = __b2_out.0;
+    let __v_9: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record) };
+    let __v_10: G = __b2_out.0;
+    let __v_11: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record) };
+    let __v_12: G = __b2_out.0;
+    let __v_13: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record) };
+    let __v_14: G = __b2_out.0;
+    let __v_15: G = __b2_out.1;
+    let __v_16: G = (__v_10 + __v_13);
+    let __v_17: G = (__v_12 + __v_15);
+    let __v_18: G = (__v_14 + __v_9);
+    let __v_19: G = (__v_8 + __v_11);
+    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[11].weight(); } record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 8;
+fn aiur_fn_12(
+  inp: [G; IN_12],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_12], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    match __v_0.as_canonical_u64() {
+      255u64 => {
+        match __v_1.as_canonical_u64() {
+          255u64 => {
+            match __v_2.as_canonical_u64() {
+              255u64 => {
+                match __v_3.as_canonical_u64() {
+                  255u64 => {
+                    match __v_4.as_canonical_u64() {
+                      255u64 => {
+                        match __v_5.as_canonical_u64() {
+                          255u64 => {
+                            match __v_6.as_canonical_u64() {
+                              255u64 => {
+                                match __v_7.as_canonical_u64() {
+                                  255u64 => {
+                                    let __v_8: G = G::from_u64(0);
+                                    let __v_9: G = G::from_u64(0);
+                                    let __v_10: G = G::from_u64(0);
+                                    let __v_11: G = G::from_u64(0);
+                                    let __v_12: G = G::from_u64(0);
+                                    let __v_13: G = G::from_u64(0);
+                                    let __v_14: G = G::from_u64(0);
+                                    let __v_15: G = G::from_u64(0);
+                                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_8: G = G::from_u64(0);
+                                    let __v_9: G = G::from_u64(0);
+                                    let __v_10: G = G::from_u64(0);
+                                    let __v_11: G = G::from_u64(0);
+                                    let __v_12: G = G::from_u64(0);
+                                    let __v_13: G = G::from_u64(0);
+                                    let __v_14: G = G::from_u64(0);
+                                    let __v_15: G = G::from_u64(1);
+                                    let __v_16: G = (__v_7 + __v_15);
+                                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_8: G = G::from_u64(0);
+                                let __v_9: G = G::from_u64(0);
+                                let __v_10: G = G::from_u64(0);
+                                let __v_11: G = G::from_u64(0);
+                                let __v_12: G = G::from_u64(0);
+                                let __v_13: G = G::from_u64(0);
+                                let __v_14: G = G::from_u64(1);
+                                let __v_15: G = (__v_6 + __v_14);
+                                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_8: G = G::from_u64(0);
+                            let __v_9: G = G::from_u64(0);
+                            let __v_10: G = G::from_u64(0);
+                            let __v_11: G = G::from_u64(0);
+                            let __v_12: G = G::from_u64(0);
+                            let __v_13: G = G::from_u64(1);
+                            let __v_14: G = (__v_5 + __v_13);
+                            let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_8: G = G::from_u64(0);
+                        let __v_9: G = G::from_u64(0);
+                        let __v_10: G = G::from_u64(0);
+                        let __v_11: G = G::from_u64(0);
+                        let __v_12: G = G::from_u64(1);
+                        let __v_13: G = (__v_4 + __v_12);
+                        let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_8: G = G::from_u64(0);
+                    let __v_9: G = G::from_u64(0);
+                    let __v_10: G = G::from_u64(0);
+                    let __v_11: G = G::from_u64(1);
+                    let __v_12: G = (__v_3 + __v_11);
+                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_8: G = G::from_u64(0);
+                let __v_9: G = G::from_u64(0);
+                let __v_10: G = G::from_u64(1);
+                let __v_11: G = (__v_2 + __v_10);
+                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_1 + __v_9);
+            let __ret: [G; OUT_12] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_0 + __v_8);
+        let __ret: [G; OUT_12] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_13: usize = 8;
+const IN_13: usize = 8;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_13], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(0);
+    if (__v_7 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) });
+    }
+    let __v_9: G = G::from_u64(256);
+    let __v_10: G = (__v_9 * __v_1);
+    let __v_11: G = G::from_u64(65536);
+    let __v_12: G = (__v_11 * __v_2);
+    let __v_13: G = G::from_u64(16777216);
+    let __v_14: G = (__v_13 * __v_3);
+    let __v_15: G = G::from_u64(4294967296);
+    let __v_16: G = (__v_15 * __v_4);
+    let __v_17: G = G::from_u64(1099511627776);
+    let __v_18: G = (__v_17 * __v_5);
+    let __v_19: G = G::from_u64(281474976710656);
+    let __v_20: G = (__v_19 * __v_6);
+    let __v_21: G = (__v_18 + __v_20);
+    let __v_22: G = (__v_16 + __v_21);
+    let __v_23: G = (__v_14 + __v_22);
+    let __v_24: G = (__v_12 + __v_23);
+    let __v_25: G = (__v_10 + __v_24);
+    let __v_26: G = (__v_0 + __v_25);
+    let __ret: [G; OUT_13] = [__v_26];
+    if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_14: usize = 8;
+const IN_14: usize = 8;
+const OUT_14: usize = 1;
+fn aiur_fn_14(
+  inp: [G; IN_14],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_14], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(256);
+    let __v_9: G = (__v_8 * __v_1);
+    let __v_10: G = G::from_u64(65536);
+    let __v_11: G = (__v_10 * __v_2);
+    let __v_12: G = G::from_u64(16777216);
+    let __v_13: G = (__v_12 * __v_3);
+    let __v_14: G = G::from_u64(4294967296);
+    let __v_15: G = (__v_14 * __v_4);
+    let __v_16: G = G::from_u64(1099511627776);
+    let __v_17: G = (__v_16 * __v_5);
+    let __v_18: G = G::from_u64(281474976710656);
+    let __v_19: G = (__v_18 * __v_6);
+    let __v_20: G = G::from_u64(72057594037927936);
+    let __v_21: G = (__v_20 * __v_7);
+    let __v_22: G = (__v_19 + __v_21);
+    let __v_23: G = (__v_17 + __v_22);
+    let __v_24: G = (__v_15 + __v_23);
+    let __v_25: G = (__v_13 + __v_24);
+    let __v_26: G = (__v_11 + __v_25);
+    let __v_27: G = (__v_9 + __v_26);
+    let __v_28: G = (__v_0 + __v_27);
+    let __ret: [G; OUT_14] = [__v_28];
+    if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_15: usize = 8;
+const IN_15: usize = 8;
+const OUT_15: usize = 1;
+fn aiur_fn_15(
+  inp: [G; IN_15],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_15], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(1020);
+    let __v_9: G = (__v_7 - __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_5 + __v_10);
+    let __v_12: G = (__v_4 + __v_11);
+    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
+    let __v_14: G = (__v_2 + __v_3);
+    let __v_15: G = (__v_1 + __v_14);
+    let __v_16: G = (__v_0 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(1);
+    let __v_20: G = (__v_19 - __v_17);
+    let __v_21: G = (__v_13 * __v_20);
+    let __v_22: G = (__v_18 - __v_21);
+    let __ret: [G; OUT_15] = [__v_22];
+    if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 8;
+fn aiur_fn_16(
+  inp: [G; IN_16],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_16], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
+    let __v_1: G = G::from_u8(__gb[0]);
+    let __v_2: G = G::from_u8(__gb[1]);
+    let __v_3: G = G::from_u8(__gb[2]);
+    let __v_4: G = G::from_u8(__gb[3]);
+    let __v_5: G = G::from_u8(__gb[4]);
+    let __v_6: G = G::from_u8(__gb[5]);
+    let __v_7: G = G::from_u8(__gb[6]);
+    let __v_8: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_9: G = G::from_u64(1020);
+    let __v_10: G = (__v_8 - __v_9);
+    let __v_11: G = (__v_7 + __v_10);
+    let __v_12: G = (__v_6 + __v_11);
+    let __v_13: G = (__v_5 + __v_12);
+    let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+    let __v_15: G = (__v_3 + __v_4);
+    let __v_16: G = (__v_2 + __v_15);
+    let __v_17: G = (__v_1 + __v_16);
+    let __v_18: G = G::from_bool((__v_17 == G::ZERO));
+    let __v_19: G = G::from_u64(256);
+    let __v_20: G = (__v_19 * __v_2);
+    let __v_21: G = G::from_u64(65536);
+    let __v_22: G = (__v_21 * __v_3);
+    let __v_23: G = G::from_u64(16777216);
+    let __v_24: G = (__v_23 * __v_4);
+    let __v_25: G = G::from_u64(4294967296);
+    let __v_26: G = (__v_25 * __v_5);
+    let __v_27: G = G::from_u64(1099511627776);
+    let __v_28: G = (__v_27 * __v_6);
+    let __v_29: G = G::from_u64(281474976710656);
+    let __v_30: G = (__v_29 * __v_7);
+    let __v_31: G = G::from_u64(72057594037927936);
+    let __v_32: G = (__v_31 * __v_8);
+    let __v_33: G = (__v_30 + __v_32);
+    let __v_34: G = (__v_28 + __v_33);
+    let __v_35: G = (__v_26 + __v_34);
+    let __v_36: G = (__v_24 + __v_35);
+    let __v_37: G = (__v_22 + __v_36);
+    let __v_38: G = (__v_20 + __v_37);
+    let __v_39: G = (__v_1 + __v_38);
+    if (__v_39 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    let __v_40: G = G::from_u64(1);
+    let __v_41: G = G::from_u64(1);
+    let __v_42: G = (__v_41 - __v_18);
+    let __v_43: G = (__v_14 * __v_42);
+    let __v_44: G = (__v_40 - __v_43);
+    let __v_45: G = G::from_u64(1);
+    if (__v_44 != __v_45) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_17: usize = 1;
+const IN_17: usize = 1;
+const OUT_17: usize = 1;
+fn aiur_fn_17(
+  inp: [G; IN_17],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_17], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = g_inverse_value(__v_0);
+    let __v_2: G = (__v_0 * __v_1);
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_2 - __v_3);
+    let __v_5: G = (__v_0 * __v_4);
+    let __v_6: G = G::from_u64(0);
+    if (__v_5 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
+    }
+    let __v_7: G = (__v_1 * __v_4);
+    let __v_8: G = G::from_u64(0);
+    if (__v_7 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_17] = [__v_1];
+    if !unconstrained { record.virt += record.function_queries[17].weight(); } record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_18: usize = 4;
+const IN_18: usize = 4;
+const OUT_18: usize = 2;
+fn aiur_fn_18(
+  inp: [G; IN_18],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_18], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 + __v_2);
+    let __v_5: G = (__v_1 + __v_3);
+    let __ret: [G; OUT_18] = [__v_4, __v_5];
+    if !unconstrained { record.virt += record.function_queries[18].weight(); } record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_19: usize = 4;
+const IN_19: usize = 4;
+const OUT_19: usize = 2;
+fn aiur_fn_19(
+  inp: [G; IN_19],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_19], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 - __v_2);
+    let __v_5: G = (__v_1 - __v_3);
+    let __ret: [G; OUT_19] = [__v_4, __v_5];
+    if !unconstrained { record.virt += record.function_queries[19].weight(); } record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_20: usize = 2;
+const IN_20: usize = 2;
+const OUT_20: usize = 2;
+fn aiur_fn_20(
+  inp: [G; IN_20],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_20], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = (__v_2 - __v_0);
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = (__v_4 - __v_1);
+    let __ret: [G; OUT_20] = [__v_3, __v_5];
+    if !unconstrained { record.virt += record.function_queries[20].weight(); } record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_21: usize = 4;
+const IN_21: usize = 4;
+const OUT_21: usize = 2;
+fn aiur_fn_21(
+  inp: [G; IN_21],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_21], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 * __v_2);
+    let __v_5: G = G::from_u64(7);
+    let __v_6: G = (__v_1 * __v_3);
+    let __v_7: G = (__v_5 * __v_6);
+    let __v_8: G = (__v_4 + __v_7);
+    let __v_9: G = (__v_0 * __v_3);
+    let __v_10: G = (__v_1 * __v_2);
+    let __v_11: G = (__v_9 + __v_10);
+    let __ret: [G; OUT_21] = [__v_8, __v_11];
+    if !unconstrained { record.virt += record.function_queries[21].weight(); } record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_22: usize = 2;
+const IN_22: usize = 2;
+const OUT_22: usize = 2;
+fn aiur_fn_22(
+  inp: [G; IN_22],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_22], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = (__v_0 * __v_0);
+    let __v_3: G = G::from_u64(7);
+    let __v_4: G = (__v_1 * __v_1);
+    let __v_5: G = (__v_3 * __v_4);
+    let __v_6: G = (__v_2 - __v_5);
+    let __v_7: G = g_inverse_value(__v_6);
+    let __v_8: G = (__v_6 * __v_7);
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = (__v_8 - __v_9);
+    let __v_11: G = (__v_6 * __v_10);
+    let __v_12: G = G::from_u64(0);
+    if (__v_11 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    }
+    let __v_13: G = (__v_7 * __v_10);
+    let __v_14: G = G::from_u64(0);
+    if (__v_13 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    }
+    let __v_15: G = (__v_0 * __v_7);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = (__v_16 - __v_1);
+    let __v_18: G = (__v_17 * __v_7);
+    let __ret: [G; OUT_22] = [__v_15, __v_18];
+    if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_23: usize = 4;
+const IN_23: usize = 4;
+const OUT_23: usize = 2;
+fn aiur_fn_23(
+  inp: [G; IN_23],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_23], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_2 * __v_2);
+    let __v_5: G = G::from_u64(7);
+    let __v_6: G = (__v_3 * __v_3);
+    let __v_7: G = (__v_5 * __v_6);
+    let __v_8: G = (__v_4 - __v_7);
+    let __v_9: G = g_inverse_value(__v_8);
+    let __v_10: G = (__v_8 * __v_9);
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = (__v_10 - __v_11);
+    let __v_13: G = (__v_8 * __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: None });
+    }
+    let __v_15: G = (__v_9 * __v_12);
+    let __v_16: G = G::from_u64(0);
+    if (__v_15 != __v_16) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
+    }
+    let __v_17: G = (__v_2 * __v_9);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = (__v_18 - __v_3);
+    let __v_20: G = (__v_19 * __v_9);
+    let __v_21: G = (__v_0 * __v_17);
+    let __v_22: G = G::from_u64(7);
+    let __v_23: G = (__v_1 * __v_20);
+    let __v_24: G = (__v_22 * __v_23);
+    let __v_25: G = (__v_21 + __v_24);
+    let __v_26: G = (__v_0 * __v_20);
+    let __v_27: G = (__v_1 * __v_17);
+    let __v_28: G = (__v_26 + __v_27);
+    let __ret: [G; OUT_23] = [__v_25, __v_28];
+    if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_24: usize = 4;
+const IN_24: usize = 4;
+const OUT_24: usize = 1;
+fn aiur_fn_24(
+  inp: [G; IN_24],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_24], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = (__v_0 - __v_2);
+    let __v_5: G = G::from_bool((__v_4 == G::ZERO));
+    let __v_6: G = (__v_1 - __v_3);
+    let __v_7: G = G::from_bool((__v_6 == G::ZERO));
+    let __v_8: G = (__v_5 * __v_7);
+    let __ret: [G; OUT_24] = [__v_8];
+    if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 2;
+fn aiur_fn_25(
+  inp: [G; IN_25],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_25], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __ret: [G; OUT_25] = [__v_2, __v_3];
+        if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_25] = [__v_4, __v_7];
+        if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 9;
+fn aiur_fn_26(
+  inp: [G; IN_26],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_26], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_26] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_27: usize = 1;
+const IN_27: usize = 1;
+const OUT_27: usize = 2;
+fn aiur_fn_27(
+  inp: [G; IN_27],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_27], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_27] = [__v_10, __v_9];
+    if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 2;
+fn aiur_fn_28(
+  inp: [G; IN_28],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_28], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_0 + __v_3);
+    let __ret: [G; OUT_28] = [__v_2, __v_4];
+    if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 9;
+fn aiur_fn_29(
+  inp: [G; IN_29],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_29], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __io_read[0];
+    let __v_3: G = __io_read[1];
+    let __v_4: G = __io_read[2];
+    let __v_5: G = __io_read[3];
+    let __v_6: G = __io_read[4];
+    let __v_7: G = __io_read[5];
+    let __v_8: G = __io_read[6];
+    let __v_9: G = __io_read[7];
+    let __v_10: G = G::from_u64(8);
+    let __v_11: G = (__v_0 + __v_10);
+    let __ret: [G; OUT_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 2;
+fn aiur_fn_30(
+  inp: [G; IN_30],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_30], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_30] = [__v_10, __v_9];
+    if !unconstrained { record.virt += record.function_queries[30].weight(); } record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 3;
+fn aiur_fn_31(
+  inp: [G; IN_31],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_31], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __v_19: G = G::from_u64(256);
+    let __v_20: G = (__v_19 * __v_2);
+    let __v_21: G = G::from_u64(65536);
+    let __v_22: G = (__v_21 * __v_3);
+    let __v_23: G = G::from_u64(16777216);
+    let __v_24: G = (__v_23 * __v_4);
+    let __v_25: G = G::from_u64(4294967296);
+    let __v_26: G = (__v_25 * __v_5);
+    let __v_27: G = G::from_u64(1099511627776);
+    let __v_28: G = (__v_27 * __v_6);
+    let __v_29: G = G::from_u64(281474976710656);
+    let __v_30: G = (__v_29 * __v_7);
+    let __v_31: G = G::from_u64(72057594037927936);
+    let __v_32: G = (__v_31 * __v_8);
+    let __v_33: G = (__v_30 + __v_32);
+    let __v_34: G = (__v_28 + __v_33);
+    let __v_35: G = (__v_26 + __v_34);
+    let __v_36: G = (__v_24 + __v_35);
+    let __v_37: G = (__v_22 + __v_36);
+    let __v_38: G = (__v_20 + __v_37);
+    let __v_39: G = (__v_1 + __v_38);
+    let __v_40: G = G::from_u64(256);
+    let __v_41: G = (__v_40 * __v_11);
+    let __v_42: G = G::from_u64(65536);
+    let __v_43: G = (__v_42 * __v_12);
+    let __v_44: G = G::from_u64(16777216);
+    let __v_45: G = (__v_44 * __v_13);
+    let __v_46: G = G::from_u64(4294967296);
+    let __v_47: G = (__v_46 * __v_14);
+    let __v_48: G = G::from_u64(1099511627776);
+    let __v_49: G = (__v_48 * __v_15);
+    let __v_50: G = G::from_u64(281474976710656);
+    let __v_51: G = (__v_50 * __v_16);
+    let __v_52: G = G::from_u64(72057594037927936);
+    let __v_53: G = (__v_52 * __v_17);
+    let __v_54: G = (__v_51 + __v_53);
+    let __v_55: G = (__v_49 + __v_54);
+    let __v_56: G = (__v_47 + __v_55);
+    let __v_57: G = (__v_45 + __v_56);
+    let __v_58: G = (__v_43 + __v_57);
+    let __v_59: G = (__v_41 + __v_58);
+    let __v_60: G = (__v_10 + __v_59);
+    let __ret: [G; OUT_31] = [__v_39, __v_60, __v_18];
+    if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_32: usize = 1;
+const IN_32: usize = 1;
+const OUT_32: usize = 33;
+fn aiur_fn_32(
+  inp: [G; IN_32],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_32], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_33: usize = 1;
+const IN_33: usize = 1;
+const OUT_33: usize = 2;
+fn aiur_fn_33(
+  inp: [G; IN_33],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_33], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_33] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_34: usize = 2;
+const IN_34: usize = 2;
+const OUT_34: usize = 2;
+fn aiur_fn_34(
+  inp: [G; IN_34],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_34], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_34] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_34] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_35: usize = 1;
+const IN_35: usize = 1;
+const OUT_35: usize = 2;
+fn aiur_fn_35(
+  inp: [G; IN_35],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_35], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_35] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_36: usize = 2;
+const IN_36: usize = 2;
+const OUT_36: usize = 2;
+fn aiur_fn_36(
+  inp: [G; IN_36],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_36], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_36] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_36] = [__v_16, __v_14];
+        if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_37: usize = 1;
+const IN_37: usize = 1;
+const OUT_37: usize = 2;
+fn aiur_fn_37(
+  inp: [G; IN_37],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_37], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_37] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_38: usize = 2;
+const IN_38: usize = 2;
+const OUT_38: usize = 2;
+fn aiur_fn_38(
+  inp: [G; IN_38],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_38], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_38] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = __r_arr[2];
+        let __v_14: G = __r_arr[3];
+        let __v_15: G = __r_arr[4];
+        let __v_16: G = __r_arr[5];
+        let __v_17: G = __r_arr[6];
+        let __v_18: G = __r_arr[7];
+        let __v_19: G = __r_arr[8];
+        let __v_20: G = G::from_u64(256);
+        let __v_21: G = (__v_20 * __v_3);
+        let __v_22: G = G::from_u64(65536);
+        let __v_23: G = (__v_22 * __v_4);
+        let __v_24: G = G::from_u64(16777216);
+        let __v_25: G = (__v_24 * __v_5);
+        let __v_26: G = G::from_u64(4294967296);
+        let __v_27: G = (__v_26 * __v_6);
+        let __v_28: G = G::from_u64(1099511627776);
+        let __v_29: G = (__v_28 * __v_7);
+        let __v_30: G = G::from_u64(281474976710656);
+        let __v_31: G = (__v_30 * __v_8);
+        let __v_32: G = G::from_u64(72057594037927936);
+        let __v_33: G = (__v_32 * __v_9);
+        let __v_34: G = (__v_31 + __v_33);
+        let __v_35: G = (__v_29 + __v_34);
+        let __v_36: G = (__v_27 + __v_35);
+        let __v_37: G = (__v_25 + __v_36);
+        let __v_38: G = (__v_23 + __v_37);
+        let __v_39: G = (__v_21 + __v_38);
+        let __v_40: G = (__v_2 + __v_39);
+        let __v_41: G = G::from_u64(256);
+        let __v_42: G = (__v_41 * __v_12);
+        let __v_43: G = G::from_u64(65536);
+        let __v_44: G = (__v_43 * __v_13);
+        let __v_45: G = G::from_u64(16777216);
+        let __v_46: G = (__v_45 * __v_14);
+        let __v_47: G = G::from_u64(4294967296);
+        let __v_48: G = (__v_47 * __v_15);
+        let __v_49: G = G::from_u64(1099511627776);
+        let __v_50: G = (__v_49 * __v_16);
+        let __v_51: G = G::from_u64(281474976710656);
+        let __v_52: G = (__v_51 * __v_17);
+        let __v_53: G = G::from_u64(72057594037927936);
+        let __v_54: G = (__v_53 * __v_18);
+        let __v_55: G = (__v_52 + __v_54);
+        let __v_56: G = (__v_50 + __v_55);
+        let __v_57: G = (__v_48 + __v_56);
+        let __v_58: G = (__v_46 + __v_57);
+        let __v_59: G = (__v_44 + __v_58);
+        let __v_60: G = (__v_42 + __v_59);
+        let __v_61: G = (__v_11 + __v_60);
+        let __v_62: G = G::from_u64(1);
+        let __v_63: G = (__v_1 - __v_62);
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_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; 4] = [__v_66, __v_40, __v_61, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_38] = [__v_67, __v_65];
+        if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_39: usize = 1;
+const IN_39: usize = 1;
+const OUT_39: usize = 2;
+fn aiur_fn_39(
+  inp: [G; IN_39],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_39], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; 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 { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_39] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_40: usize = 2;
+const IN_40: usize = 2;
+const OUT_40: usize = 2;
+fn aiur_fn_40(
+  inp: [G; IN_40],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_40], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_40] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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_29] = { let __args: [G; IN_29] = [__v_19]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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_29] = { let __args: [G; IN_29] = [__v_28]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+        let __v_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __v_32: G = __r_arr[3];
+        let __v_33: G = __r_arr[4];
+        let __v_34: G = __r_arr[5];
+        let __v_35: G = __r_arr[6];
+        let __v_36: G = __r_arr[7];
+        let __v_37: G = __r_arr[8];
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_1 - __v_38);
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; 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 { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_40] = [__v_44, __v_41];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_41: usize = 1;
+const IN_41: usize = 1;
+const OUT_41: usize = 2;
+fn aiur_fn_41(
+  inp: [G; IN_41],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_41], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_41] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_42: usize = 2;
+const IN_42: usize = 2;
+const OUT_42: usize = 2;
+fn aiur_fn_42(
+  inp: [G; IN_42],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_42], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_42] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_42] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_43: usize = 1;
+const IN_43: usize = 1;
+const OUT_43: usize = 2;
+fn aiur_fn_43(
+  inp: [G; IN_43],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_43], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_43] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_44: usize = 2;
+const IN_44: usize = 2;
+const OUT_44: usize = 2;
+fn aiur_fn_44(
+  inp: [G; IN_44],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_44], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_44] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_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_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_44] = [__v_11, __v_9];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_45: usize = 1;
+const IN_45: usize = 1;
+const OUT_45: usize = 2;
+fn aiur_fn_45(
+  inp: [G; IN_45],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_45], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_45] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_46: usize = 2;
+const IN_46: usize = 2;
+const OUT_46: usize = 2;
+fn aiur_fn_46(
+  inp: [G; IN_46],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_46], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_46] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_46] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_47: usize = 1;
+const IN_47: usize = 1;
+const OUT_47: usize = 2;
+fn aiur_fn_47(
+  inp: [G; IN_47],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_47], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; let __cu = unconstrained; 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 { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_47] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_48: usize = 2;
+const IN_48: usize = 2;
+const OUT_48: usize = 2;
+fn aiur_fn_48(
+  inp: [G; IN_48],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_48], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_48] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; 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 { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; 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 { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_48] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_49: usize = 1;
+const IN_49: usize = 1;
+const OUT_49: usize = 2;
+fn aiur_fn_49(
+  inp: [G; IN_49],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_49], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __ret: [G; OUT_49] = [__v_1, __v_2];
+    if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
+const OUT_50: usize = 2;
+fn aiur_fn_50(
+  inp: [G; IN_50],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_50], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_51: usize = 2;
+const IN_51: usize = 2;
+const OUT_51: usize = 2;
+fn aiur_fn_51(
+  inp: [G; IN_51],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_51], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_51] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; 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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_51] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_52: usize = 1;
+const IN_52: usize = 1;
+const OUT_52: usize = 4;
+fn aiur_fn_52(
+  inp: [G; IN_52],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_52], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_52] = [__v_1, __v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 3;
+fn aiur_fn_53(
+  inp: [G; IN_53],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_53], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_53] = [__v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_54: usize = 1;
+const IN_54: usize = 1;
+const OUT_54: usize = 2;
+fn aiur_fn_54(
+  inp: [G; IN_54],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_54], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __cu = unconstrained; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_54] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_55: usize = 2;
+const IN_55: usize = 2;
+const OUT_55: usize = 2;
+fn aiur_fn_55(
+  inp: [G; IN_55],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_55], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_55] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_1 - __v_8);
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[1];
+        let __v_12: G = G::from_u64(0);
+        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_55] = [__v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_56: usize = 1;
+const IN_56: usize = 1;
+const OUT_56: usize = 4;
+fn aiur_fn_56(
+  inp: [G; IN_56],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_56], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __ret: [G; OUT_56] = [__v_1, __v_5, __v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_57: usize = 1;
+const IN_57: usize = 1;
+const OUT_57: usize = 2;
+fn aiur_fn_57(
+  inp: [G; IN_57],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_57], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_57] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+const OUT_58: usize = 2;
+fn aiur_fn_58(
+  inp: [G; IN_58],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_58], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_58] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__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_1 - __v_10);
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_58] = [__v_15, __v_13];
+        if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_59: usize = 1;
+const IN_59: usize = 1;
+const OUT_59: usize = 14;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __v_19: G = __r_arr[2];
+    let __v_20: G = __r_arr[3];
+    let __v_21: G = __r_arr[4];
+    let __v_22: G = __r_arr[5];
+    let __v_23: G = __r_arr[6];
+    let __v_24: G = __r_arr[7];
+    let __v_25: G = __r_arr[8];
+    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+    if !unconstrained { record.virt += record.function_queries[59].weight(); } record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_60: usize = 1;
+const IN_60: usize = 1;
+const OUT_60: usize = 3;
+fn aiur_fn_60(
+  inp: [G; IN_60],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_60], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 25;
+fn aiur_fn_61(
+  inp: [G; IN_61],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_61], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = __r_arr[0];
+    let __v_8: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_23: G = __r_arr[0];
+    let __v_24: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+    let __v_26: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_27: G = __r_arr[0];
+    let __v_28: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+    let __v_30: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __v_34: G = __r_arr[1];
+    let __v_35: G = __r_arr[2];
+    let __v_36: G = __r_arr[3];
+    let __v_37: G = __r_arr[4];
+    let __v_38: G = __r_arr[5];
+    let __v_39: G = __r_arr[6];
+    let __v_40: G = __r_arr[7];
+    let __v_41: G = __r_arr[8];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; 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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+    let __v_45: G = __r_arr[1];
+    let __v_46: G = __r_arr[2];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __ret: [G; OUT_61] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50];
+    if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_62: usize = 4;
+const IN_62: usize = 4;
+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_62], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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(256);
+    let __v_5: G = (__v_4 * __v_1);
+    let __v_6: G = G::from_u64(65536);
+    let __v_7: G = (__v_6 * __v_2);
+    let __v_8: G = G::from_u64(16777216);
+    let __v_9: G = (__v_8 * __v_3);
+    let __v_10: G = (__v_7 + __v_9);
+    let __v_11: G = (__v_5 + __v_10);
+    let __v_12: G = (__v_0 + __v_11);
+    let __ret: [G; OUT_62] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_63: usize = 32;
+const IN_63: usize = 32;
+const OUT_63: usize = 8;
+fn aiur_fn_63(
+  inp: [G; IN_63],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_63], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = G::from_u64(256);
+    let __v_33: G = (__v_32 * __v_1);
+    let __v_34: G = G::from_u64(65536);
+    let __v_35: G = (__v_34 * __v_2);
+    let __v_36: G = G::from_u64(16777216);
+    let __v_37: G = (__v_36 * __v_3);
+    let __v_38: G = (__v_35 + __v_37);
+    let __v_39: G = (__v_33 + __v_38);
+    let __v_40: G = (__v_0 + __v_39);
+    let __v_41: G = G::from_u64(256);
+    let __v_42: G = (__v_41 * __v_5);
+    let __v_43: G = G::from_u64(65536);
+    let __v_44: G = (__v_43 * __v_6);
+    let __v_45: G = G::from_u64(16777216);
+    let __v_46: G = (__v_45 * __v_7);
+    let __v_47: G = (__v_44 + __v_46);
+    let __v_48: G = (__v_42 + __v_47);
+    let __v_49: G = (__v_4 + __v_48);
+    let __v_50: G = G::from_u64(256);
+    let __v_51: G = (__v_50 * __v_9);
+    let __v_52: G = G::from_u64(65536);
+    let __v_53: G = (__v_52 * __v_10);
+    let __v_54: G = G::from_u64(16777216);
+    let __v_55: G = (__v_54 * __v_11);
+    let __v_56: G = (__v_53 + __v_55);
+    let __v_57: G = (__v_51 + __v_56);
+    let __v_58: G = (__v_8 + __v_57);
+    let __v_59: G = G::from_u64(256);
+    let __v_60: G = (__v_59 * __v_13);
+    let __v_61: G = G::from_u64(65536);
+    let __v_62: G = (__v_61 * __v_14);
+    let __v_63: G = G::from_u64(16777216);
+    let __v_64: G = (__v_63 * __v_15);
+    let __v_65: G = (__v_62 + __v_64);
+    let __v_66: G = (__v_60 + __v_65);
+    let __v_67: G = (__v_12 + __v_66);
+    let __v_68: G = G::from_u64(256);
+    let __v_69: G = (__v_68 * __v_17);
+    let __v_70: G = G::from_u64(65536);
+    let __v_71: G = (__v_70 * __v_18);
+    let __v_72: G = G::from_u64(16777216);
+    let __v_73: G = (__v_72 * __v_19);
+    let __v_74: G = (__v_71 + __v_73);
+    let __v_75: G = (__v_69 + __v_74);
+    let __v_76: G = (__v_16 + __v_75);
+    let __v_77: G = G::from_u64(256);
+    let __v_78: G = (__v_77 * __v_21);
+    let __v_79: G = G::from_u64(65536);
+    let __v_80: G = (__v_79 * __v_22);
+    let __v_81: G = G::from_u64(16777216);
+    let __v_82: G = (__v_81 * __v_23);
+    let __v_83: G = (__v_80 + __v_82);
+    let __v_84: G = (__v_78 + __v_83);
+    let __v_85: G = (__v_20 + __v_84);
+    let __v_86: G = G::from_u64(256);
+    let __v_87: G = (__v_86 * __v_25);
+    let __v_88: G = G::from_u64(65536);
+    let __v_89: G = (__v_88 * __v_26);
+    let __v_90: G = G::from_u64(16777216);
+    let __v_91: G = (__v_90 * __v_27);
+    let __v_92: G = (__v_89 + __v_91);
+    let __v_93: G = (__v_87 + __v_92);
+    let __v_94: G = (__v_24 + __v_93);
+    let __v_95: G = G::from_u64(256);
+    let __v_96: G = (__v_95 * __v_29);
+    let __v_97: G = G::from_u64(65536);
+    let __v_98: G = (__v_97 * __v_30);
+    let __v_99: G = G::from_u64(16777216);
+    let __v_100: G = (__v_99 * __v_31);
+    let __v_101: G = (__v_98 + __v_100);
+    let __v_102: G = (__v_96 + __v_101);
+    let __v_103: G = (__v_28 + __v_102);
+    let __ret: [G; OUT_63] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_64: usize = 1;
+const IN_64: usize = 1;
+const OUT_64: usize = 32;
+fn aiur_fn_64(
+  inp: [G; IN_64],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_64], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __v_61: G = __r_arr[9];
+    let __v_62: G = __r_arr[10];
+    let __v_63: G = __r_arr[11];
+    let __v_64: G = __r_arr[12];
+    let __v_65: G = __r_arr[13];
+    let __v_66: G = __r_arr[14];
+    let __v_67: G = __r_arr[15];
+    let __v_68: G = __r_arr[16];
+    let __v_69: G = __r_arr[17];
+    let __v_70: G = __r_arr[18];
+    let __v_71: G = __r_arr[19];
+    let __v_72: G = __r_arr[20];
+    let __v_73: G = __r_arr[21];
+    let __v_74: G = __r_arr[22];
+    let __v_75: G = __r_arr[23];
+    let __v_76: G = __r_arr[24];
+    let __v_77: G = __r_arr[25];
+    let __v_78: G = __r_arr[26];
+    let __v_79: G = __r_arr[27];
+    let __v_80: G = __r_arr[28];
+    let __v_81: G = __r_arr[29];
+    let __v_82: G = __r_arr[30];
+    let __v_83: G = __r_arr[31];
+    let __ret: [G; OUT_64] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83];
+    if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_65: usize = 1;
+const IN_65: usize = 1;
+const OUT_65: usize = 1;
+fn aiur_fn_65(
+  inp: [G; IN_65],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_65], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __v_61: G = __r_arr[9];
+    let __v_62: G = __r_arr[10];
+    let __v_63: G = __r_arr[11];
+    let __v_64: G = __r_arr[12];
+    let __v_65: G = __r_arr[13];
+    let __v_66: G = __r_arr[14];
+    let __v_67: G = __r_arr[15];
+    let __v_68: G = __r_arr[16];
+    let __v_69: G = __r_arr[17];
+    let __v_70: G = __r_arr[18];
+    let __v_71: G = __r_arr[19];
+    let __v_72: G = __r_arr[20];
+    let __v_73: G = __r_arr[21];
+    let __v_74: G = __r_arr[22];
+    let __v_75: G = __r_arr[23];
+    let __v_76: G = __r_arr[24];
+    let __v_77: G = __r_arr[25];
+    let __v_78: G = __r_arr[26];
+    let __v_79: G = __r_arr[27];
+    let __v_80: G = __r_arr[28];
+    let __v_81: G = __r_arr[29];
+    let __v_82: G = __r_arr[30];
+    let __v_83: G = __r_arr[31];
+    let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_65] = [__v_84];
+    if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_66: usize = 34;
+const IN_66: usize = 34;
+const OUT_66: usize = 34;
+fn aiur_fn_66(
+  inp: [G; IN_66],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_66], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = __loaded[32];
+    let __v_67: G = __loaded[33];
+    match __v_34.as_canonical_u64() {
+      1u64 => {
+        let __v_68: G = G::from_u64(1);
+        let __ret: [G; OUT_66] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
+        if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_68: G = G::from_u64(0);
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_35, __v_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]; 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 { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
+        let __v_70: G = __r_arr[1];
+        let __v_71: G = __r_arr[2];
+        let __v_72: G = __r_arr[3];
+        let __v_73: G = __r_arr[4];
+        let __v_74: G = __r_arr[5];
+        let __v_75: G = __r_arr[6];
+        let __v_76: G = __r_arr[7];
+        let __v_77: G = __r_arr[8];
+        let __v_78: G = __r_arr[9];
+        let __v_79: G = __r_arr[10];
+        let __v_80: G = __r_arr[11];
+        let __v_81: G = __r_arr[12];
+        let __v_82: G = __r_arr[13];
+        let __v_83: G = __r_arr[14];
+        let __v_84: G = __r_arr[15];
+        let __v_85: G = __r_arr[16];
+        let __v_86: G = __r_arr[17];
+        let __v_87: G = __r_arr[18];
+        let __v_88: G = __r_arr[19];
+        let __v_89: G = __r_arr[20];
+        let __v_90: G = __r_arr[21];
+        let __v_91: G = __r_arr[22];
+        let __v_92: G = __r_arr[23];
+        let __v_93: G = __r_arr[24];
+        let __v_94: G = __r_arr[25];
+        let __v_95: G = __r_arr[26];
+        let __v_96: G = __r_arr[27];
+        let __v_97: G = __r_arr[28];
+        let __v_98: G = __r_arr[29];
+        let __v_99: G = __r_arr[30];
+        let __v_100: G = __r_arr[31];
+        let __v_101: G = __r_arr[32];
+        let __v_102: G = __r_arr[33];
+        match __v_69.as_canonical_u64() {
+          0u64 => {
+            let __v_103: G = G::from_u64(1);
+            let __ret: [G; OUT_66] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
+            if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_103: G = G::from_u64(4);
+            let __v_104: G = G::from_u64(8);
+            let __v_105: G = G::from_u64(103);
+            let __v_106: G = G::from_u64(230);
+            let __v_107: G = G::from_u64(9);
+            let __v_108: G = G::from_u64(106);
+            let __v_109: G = G::from_u64(133);
+            let __v_110: G = G::from_u64(174);
+            let __v_111: G = G::from_u64(103);
+            let __v_112: G = G::from_u64(187);
+            let __v_113: G = G::from_u64(114);
+            let __v_114: G = G::from_u64(243);
+            let __v_115: G = G::from_u64(110);
+            let __v_116: G = G::from_u64(60);
+            let __v_117: G = G::from_u64(58);
+            let __v_118: G = G::from_u64(245);
+            let __v_119: G = G::from_u64(79);
+            let __v_120: G = G::from_u64(165);
+            let __v_121: G = G::from_u64(127);
+            let __v_122: G = G::from_u64(82);
+            let __v_123: G = G::from_u64(14);
+            let __v_124: G = G::from_u64(81);
+            let __v_125: G = G::from_u64(140);
+            let __v_126: G = G::from_u64(104);
+            let __v_127: G = G::from_u64(5);
+            let __v_128: G = G::from_u64(155);
+            let __v_129: G = G::from_u64(171);
+            let __v_130: G = G::from_u64(217);
+            let __v_131: G = G::from_u64(131);
+            let __v_132: G = G::from_u64(31);
+            let __v_133: G = G::from_u64(25);
+            let __v_134: G = G::from_u64(205);
+            let __v_135: G = G::from_u64(224);
+            let __v_136: G = G::from_u64(91);
+            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+            let __v_137: G = __loaded[0];
+            let __v_138: G = __loaded[1];
+            let __v_139: G = __loaded[2];
+            let __v_140: G = __loaded[3];
+            let __v_141: G = __loaded[4];
+            let __v_142: G = __loaded[5];
+            let __v_143: G = __loaded[6];
+            let __v_144: G = __loaded[7];
+            let __v_145: G = __loaded[8];
+            let __v_146: G = __loaded[9];
+            let __v_147: G = __loaded[10];
+            let __v_148: G = __loaded[11];
+            let __v_149: G = __loaded[12];
+            let __v_150: G = __loaded[13];
+            let __v_151: G = __loaded[14];
+            let __v_152: G = __loaded[15];
+            let __v_153: G = __loaded[16];
+            let __v_154: G = __loaded[17];
+            let __v_155: G = __loaded[18];
+            let __v_156: G = __loaded[19];
+            let __v_157: G = __loaded[20];
+            let __v_158: G = __loaded[21];
+            let __v_159: G = __loaded[22];
+            let __v_160: G = __loaded[23];
+            let __v_161: G = __loaded[24];
+            let __v_162: G = __loaded[25];
+            let __v_163: G = __loaded[26];
+            let __v_164: G = __loaded[27];
+            let __v_165: G = __loaded[28];
+            let __v_166: G = __loaded[29];
+            let __v_167: G = __loaded[30];
+            let __v_168: G = __loaded[31];
+            let __v_169: G = __loaded[32];
+            let __v_170: G = __loaded[33];
+            match __v_137.as_canonical_u64() {
+              1u64 => {
+                let __v_171: G = (__v_104 * __v_33);
+                let __v_172: G = (__v_103 + __v_171);
+                let __v_173: G = G::from_u64(0);
+                let __v_174: G = G::from_u64(0);
+                let __v_175: G = G::from_u64(0);
+                let __v_176: G = G::from_u64(0);
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = G::from_u64(0);
+                let __v_180: G = G::from_u64(0);
+                let __v_181: G = G::from_u64(64);
+                let __v_182: G = G::from_u64(103);
+                let __v_183: G = G::from_u64(230);
+                let __v_184: G = G::from_u64(9);
+                let __v_185: G = G::from_u64(106);
+                let __v_186: G = G::from_u64(133);
+                let __v_187: G = G::from_u64(174);
+                let __v_188: G = G::from_u64(103);
+                let __v_189: G = G::from_u64(187);
+                let __v_190: G = G::from_u64(114);
+                let __v_191: G = G::from_u64(243);
+                let __v_192: G = G::from_u64(110);
+                let __v_193: G = G::from_u64(60);
+                let __v_194: G = G::from_u64(58);
+                let __v_195: G = G::from_u64(245);
+                let __v_196: G = G::from_u64(79);
+                let __v_197: G = G::from_u64(165);
+                let __v_198: G = G::from_u64(0);
+                let __v_199: G = G::from_u64(0);
+                let __v_200: G = G::from_u64(0);
+                let __v_201: G = G::from_u64(0);
+                let __v_202: G = G::from_u64(0);
+                let __v_203: G = G::from_u64(0);
+                let __v_204: G = G::from_u64(0);
+                let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_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 = __r_arr[6];
+                let __v_212: G = __r_arr[7];
+                let __v_213: G = __r_arr[8];
+                let __v_214: G = __r_arr[9];
+                let __v_215: G = __r_arr[10];
+                let __v_216: G = __r_arr[11];
+                let __v_217: G = __r_arr[12];
+                let __v_218: G = __r_arr[13];
+                let __v_219: G = __r_arr[14];
+                let __v_220: G = __r_arr[15];
+                let __v_221: G = __r_arr[16];
+                let __v_222: G = __r_arr[17];
+                let __v_223: G = __r_arr[18];
+                let __v_224: G = __r_arr[19];
+                let __v_225: G = __r_arr[20];
+                let __v_226: G = __r_arr[21];
+                let __v_227: G = __r_arr[22];
+                let __v_228: G = __r_arr[23];
+                let __v_229: G = __r_arr[24];
+                let __v_230: G = __r_arr[25];
+                let __v_231: G = __r_arr[26];
+                let __v_232: G = __r_arr[27];
+                let __v_233: G = __r_arr[28];
+                let __v_234: G = __r_arr[29];
+                let __v_235: G = __r_arr[30];
+                let __v_236: G = __r_arr[31];
+                let __v_237: G = G::from_u64(0);
+                let __v_238: G = G::from_u64(0);
+                let __v_239: G = G::from_u64(0);
+                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_66] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
+                if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_171: G = G::from_u64(0);
+                let __v_172: G = G::from_u64(0);
+                let __v_173: G = G::from_u64(0);
+                let __v_174: G = G::from_u64(0);
+                let __v_175: G = G::from_u64(0);
+                let __v_176: G = G::from_u64(0);
+                let __v_177: G = G::from_u64(0);
+                let __v_178: G = G::from_u64(0);
+                let __v_179: G = G::from_u64(64);
+                let __v_180: G = G::from_u64(103);
+                let __v_181: G = G::from_u64(230);
+                let __v_182: G = G::from_u64(9);
+                let __v_183: G = G::from_u64(106);
+                let __v_184: G = G::from_u64(133);
+                let __v_185: G = G::from_u64(174);
+                let __v_186: G = G::from_u64(103);
+                let __v_187: G = G::from_u64(187);
+                let __v_188: G = G::from_u64(114);
+                let __v_189: G = G::from_u64(243);
+                let __v_190: G = G::from_u64(110);
+                let __v_191: G = G::from_u64(60);
+                let __v_192: G = G::from_u64(58);
+                let __v_193: G = G::from_u64(245);
+                let __v_194: G = G::from_u64(79);
+                let __v_195: G = G::from_u64(165);
+                let __v_196: G = G::from_u64(0);
+                let __v_197: G = G::from_u64(0);
+                let __v_198: G = G::from_u64(0);
+                let __v_199: G = G::from_u64(0);
+                let __v_200: G = G::from_u64(0);
+                let __v_201: G = G::from_u64(0);
+                let __v_202: G = G::from_u64(0);
+                let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_203: G = __r_arr[0];
+                let __v_204: G = __r_arr[1];
+                let __v_205: G = __r_arr[2];
+                let __v_206: G = __r_arr[3];
+                let __v_207: G = __r_arr[4];
+                let __v_208: G = __r_arr[5];
+                let __v_209: G = __r_arr[6];
+                let __v_210: G = __r_arr[7];
+                let __v_211: G = __r_arr[8];
+                let __v_212: G = __r_arr[9];
+                let __v_213: G = __r_arr[10];
+                let __v_214: G = __r_arr[11];
+                let __v_215: G = __r_arr[12];
+                let __v_216: G = __r_arr[13];
+                let __v_217: G = __r_arr[14];
+                let __v_218: G = __r_arr[15];
+                let __v_219: G = __r_arr[16];
+                let __v_220: G = __r_arr[17];
+                let __v_221: G = __r_arr[18];
+                let __v_222: G = __r_arr[19];
+                let __v_223: G = __r_arr[20];
+                let __v_224: G = __r_arr[21];
+                let __v_225: G = __r_arr[22];
+                let __v_226: G = __r_arr[23];
+                let __v_227: G = __r_arr[24];
+                let __v_228: G = __r_arr[25];
+                let __v_229: G = __r_arr[26];
+                let __v_230: G = __r_arr[27];
+                let __v_231: G = __r_arr[28];
+                let __v_232: G = __r_arr[29];
+                let __v_233: G = __r_arr[30];
+                let __v_234: G = __r_arr[31];
+                let __v_235: G = G::from_u64(0);
+                let __v_236: G = G::from_u64(0);
+                let __v_237: G = G::from_u64(0);
+                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_66] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
+                if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_69.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_67: usize = 1;
+const IN_67: usize = 1;
+const OUT_67: usize = 32;
+fn aiur_fn_67(
+  inp: [G; IN_67],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_67], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = __loaded[32];
+    let __v_34: G = __loaded[33];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_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: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __v_35: G = __loaded[0];
+        let __v_36: G = __loaded[1];
+        let __v_37: G = __loaded[2];
+        let __v_38: G = __loaded[3];
+        let __v_39: G = __loaded[4];
+        let __v_40: G = __loaded[5];
+        let __v_41: G = __loaded[6];
+        let __v_42: G = __loaded[7];
+        let __v_43: G = __loaded[8];
+        let __v_44: G = __loaded[9];
+        let __v_45: G = __loaded[10];
+        let __v_46: G = __loaded[11];
+        let __v_47: G = __loaded[12];
+        let __v_48: G = __loaded[13];
+        let __v_49: G = __loaded[14];
+        let __v_50: G = __loaded[15];
+        let __v_51: G = __loaded[16];
+        let __v_52: G = __loaded[17];
+        let __v_53: G = __loaded[18];
+        let __v_54: G = __loaded[19];
+        let __v_55: G = __loaded[20];
+        let __v_56: G = __loaded[21];
+        let __v_57: G = __loaded[22];
+        let __v_58: G = __loaded[23];
+        let __v_59: G = __loaded[24];
+        let __v_60: G = __loaded[25];
+        let __v_61: G = __loaded[26];
+        let __v_62: G = __loaded[27];
+        let __v_63: G = __loaded[28];
+        let __v_64: G = __loaded[29];
+        let __v_65: G = __loaded[30];
+        let __v_66: G = __loaded[31];
+        let __v_67: G = __loaded[32];
+        let __v_68: G = __loaded[33];
+        match __v_35.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_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];
+            if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_69: G = G::from_u64(1);
+            let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; 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 { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
+            let __v_71: G = __r_arr[1];
+            let __v_72: G = __r_arr[2];
+            let __v_73: G = __r_arr[3];
+            let __v_74: G = __r_arr[4];
+            let __v_75: G = __r_arr[5];
+            let __v_76: G = __r_arr[6];
+            let __v_77: G = __r_arr[7];
+            let __v_78: G = __r_arr[8];
+            let __v_79: G = __r_arr[9];
+            let __v_80: G = __r_arr[10];
+            let __v_81: G = __r_arr[11];
+            let __v_82: G = __r_arr[12];
+            let __v_83: G = __r_arr[13];
+            let __v_84: G = __r_arr[14];
+            let __v_85: G = __r_arr[15];
+            let __v_86: G = __r_arr[16];
+            let __v_87: G = __r_arr[17];
+            let __v_88: G = __r_arr[18];
+            let __v_89: G = __r_arr[19];
+            let __v_90: G = __r_arr[20];
+            let __v_91: G = __r_arr[21];
+            let __v_92: G = __r_arr[22];
+            let __v_93: G = __r_arr[23];
+            let __v_94: G = __r_arr[24];
+            let __v_95: G = __r_arr[25];
+            let __v_96: G = __r_arr[26];
+            let __v_97: G = __r_arr[27];
+            let __v_98: G = __r_arr[28];
+            let __v_99: G = __r_arr[29];
+            let __v_100: G = __r_arr[30];
+            let __v_101: G = __r_arr[31];
+            let __v_102: G = __r_arr[32];
+            let __v_103: G = __r_arr[33];
+            match __v_70.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+                let __v_105: G = __r_arr[1];
+                let __v_106: G = __r_arr[2];
+                let __v_107: G = __r_arr[3];
+                let __v_108: G = __r_arr[4];
+                let __v_109: G = __r_arr[5];
+                let __v_110: G = __r_arr[6];
+                let __v_111: G = __r_arr[7];
+                let __v_112: G = __r_arr[8];
+                let __v_113: G = __r_arr[9];
+                let __v_114: G = __r_arr[10];
+                let __v_115: G = __r_arr[11];
+                let __v_116: G = __r_arr[12];
+                let __v_117: G = __r_arr[13];
+                let __v_118: G = __r_arr[14];
+                let __v_119: G = __r_arr[15];
+                let __v_120: G = __r_arr[16];
+                let __v_121: G = __r_arr[17];
+                let __v_122: G = __r_arr[18];
+                let __v_123: G = __r_arr[19];
+                let __v_124: G = __r_arr[20];
+                let __v_125: G = __r_arr[21];
+                let __v_126: G = __r_arr[22];
+                let __v_127: G = __r_arr[23];
+                let __v_128: G = __r_arr[24];
+                let __v_129: G = __r_arr[25];
+                let __v_130: G = __r_arr[26];
+                let __v_131: G = __r_arr[27];
+                let __v_132: G = __r_arr[28];
+                let __v_133: G = __r_arr[29];
+                let __v_134: G = __r_arr[30];
+                let __v_135: G = __r_arr[31];
+                let __ret: [G; OUT_67] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
+                if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_104: G = G::from_u64(0);
+                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_106: G = __r_arr[0];
+                let __v_107: G = __r_arr[1];
+                let __v_108: G = __r_arr[2];
+                let __v_109: G = __r_arr[3];
+                let __v_110: G = __r_arr[4];
+                let __v_111: G = __r_arr[5];
+                let __v_112: G = __r_arr[6];
+                let __v_113: G = __r_arr[7];
+                let __v_114: G = __r_arr[8];
+                let __v_115: G = __r_arr[9];
+                let __v_116: G = __r_arr[10];
+                let __v_117: G = __r_arr[11];
+                let __v_118: G = __r_arr[12];
+                let __v_119: G = __r_arr[13];
+                let __v_120: G = __r_arr[14];
+                let __v_121: G = __r_arr[15];
+                let __v_122: G = __r_arr[16];
+                let __v_123: G = __r_arr[17];
+                let __v_124: G = __r_arr[18];
+                let __v_125: G = __r_arr[19];
+                let __v_126: G = __r_arr[20];
+                let __v_127: G = __r_arr[21];
+                let __v_128: G = __r_arr[22];
+                let __v_129: G = __r_arr[23];
+                let __v_130: G = __r_arr[24];
+                let __v_131: G = __r_arr[25];
+                let __v_132: G = __r_arr[26];
+                let __v_133: G = __r_arr[27];
+                let __v_134: G = __r_arr[28];
+                let __v_135: G = __r_arr[29];
+                let __v_136: G = __r_arr[30];
+                let __v_137: G = __r_arr[31];
+                let __ret: [G; OUT_67] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
+                if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_68: usize = 7;
+const IN_68: usize = 7;
+const OUT_68: usize = 1;
+fn aiur_fn_68(
+  inp: [G; IN_68],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_68], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __ret: [G; OUT_68] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        match __v_2.as_canonical_u64() {
+          63u64 => {
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+            let __ret: [G; OUT_68] = [__v_12];
+            if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_2 + __v_12);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = (__v_3 + __v_14);
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+            let __ret: [G; OUT_68] = [__v_16];
+            if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_69: usize = 1;
+const IN_69: usize = 1;
+const OUT_69: usize = 64;
+fn aiur_fn_69(
+  inp: [G; IN_69],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_69], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __v_97: G = __loaded[0];
+                                                                                                                                    let __v_98: G = __loaded[1];
+                                                                                                                                    let __v_99: G = __loaded[2];
+                                                                                                                                    match __v_97.as_canonical_u64() {
+                                                                                                                                      0u64 => {
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __v_100: G = __loaded[0];
+                                                                                                                                        let __v_101: G = __loaded[1];
+                                                                                                                                        let __v_102: G = __loaded[2];
+                                                                                                                                        match __v_100.as_canonical_u64() {
+                                                                                                                                          0u64 => {
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __v_103: G = __loaded[0];
+                                                                                                                                            let __v_104: G = __loaded[1];
+                                                                                                                                            let __v_105: G = __loaded[2];
+                                                                                                                                            match __v_103.as_canonical_u64() {
+                                                                                                                                              0u64 => {
+                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                let __v_106: G = __loaded[0];
+                                                                                                                                                let __v_107: G = __loaded[1];
+                                                                                                                                                let __v_108: G = __loaded[2];
+                                                                                                                                                match __v_106.as_canonical_u64() {
+                                                                                                                                                  0u64 => {
+                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                    let __v_109: G = __loaded[0];
+                                                                                                                                                    let __v_110: G = __loaded[1];
+                                                                                                                                                    let __v_111: G = __loaded[2];
+                                                                                                                                                    match __v_109.as_canonical_u64() {
+                                                                                                                                                      0u64 => {
+                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                        let __v_112: G = __loaded[0];
+                                                                                                                                                        let __v_113: G = __loaded[1];
+                                                                                                                                                        let __v_114: G = __loaded[2];
+                                                                                                                                                        match __v_112.as_canonical_u64() {
+                                                                                                                                                          0u64 => {
+                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                            let __v_115: G = __loaded[0];
+                                                                                                                                                            let __v_116: G = __loaded[1];
+                                                                                                                                                            let __v_117: G = __loaded[2];
+                                                                                                                                                            match __v_115.as_canonical_u64() {
+                                                                                                                                                              0u64 => {
+                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                let __v_118: G = __loaded[0];
+                                                                                                                                                                let __v_119: G = __loaded[1];
+                                                                                                                                                                let __v_120: G = __loaded[2];
+                                                                                                                                                                match __v_118.as_canonical_u64() {
+                                                                                                                                                                  0u64 => {
+                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __v_121: G = __loaded[0];
+                                                                                                                                                                    let __v_122: G = __loaded[1];
+                                                                                                                                                                    let __v_123: G = __loaded[2];
+                                                                                                                                                                    match __v_121.as_canonical_u64() {
+                                                                                                                                                                      0u64 => {
+                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __v_124: G = __loaded[0];
+                                                                                                                                                                        let __v_125: G = __loaded[1];
+                                                                                                                                                                        let __v_126: G = __loaded[2];
+                                                                                                                                                                        match __v_124.as_canonical_u64() {
+                                                                                                                                                                          0u64 => {
+                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __v_127: G = __loaded[0];
+                                                                                                                                                                            let __v_128: G = __loaded[1];
+                                                                                                                                                                            let __v_129: G = __loaded[2];
+                                                                                                                                                                            match __v_127.as_canonical_u64() {
+                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __v_130: G = __loaded[0];
+                                                                                                                                                                                let __v_131: G = __loaded[1];
+                                                                                                                                                                                let __v_132: G = __loaded[2];
+                                                                                                                                                                                match __v_130.as_canonical_u64() {
+                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __v_133: G = __loaded[0];
+                                                                                                                                                                                    let __v_134: G = __loaded[1];
+                                                                                                                                                                                    let __v_135: G = __loaded[2];
+                                                                                                                                                                                    match __v_133.as_canonical_u64() {
+                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __v_136: G = __loaded[0];
+                                                                                                                                                                                        let __v_137: G = __loaded[1];
+                                                                                                                                                                                        let __v_138: G = __loaded[2];
+                                                                                                                                                                                        match __v_136.as_canonical_u64() {
+                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __v_139: G = __loaded[0];
+                                                                                                                                                                                            let __v_140: G = __loaded[1];
+                                                                                                                                                                                            let __v_141: G = __loaded[2];
+                                                                                                                                                                                            match __v_139.as_canonical_u64() {
+                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __v_142: G = __loaded[0];
+                                                                                                                                                                                                let __v_143: G = __loaded[1];
+                                                                                                                                                                                                let __v_144: G = __loaded[2];
+                                                                                                                                                                                                match __v_142.as_canonical_u64() {
+                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __v_145: G = __loaded[0];
+                                                                                                                                                                                                    let __v_146: G = __loaded[1];
+                                                                                                                                                                                                    let __v_147: G = __loaded[2];
+                                                                                                                                                                                                    match __v_145.as_canonical_u64() {
+                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __v_148: G = __loaded[0];
+                                                                                                                                                                                                        let __v_149: G = __loaded[1];
+                                                                                                                                                                                                        let __v_150: G = __loaded[2];
+                                                                                                                                                                                                        match __v_148.as_canonical_u64() {
+                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __v_151: G = __loaded[0];
+                                                                                                                                                                                                            let __v_152: G = __loaded[1];
+                                                                                                                                                                                                            let __v_153: G = __loaded[2];
+                                                                                                                                                                                                            match __v_151.as_canonical_u64() {
+                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __v_154: G = __loaded[0];
+                                                                                                                                                                                                                let __v_155: G = __loaded[1];
+                                                                                                                                                                                                                let __v_156: G = __loaded[2];
+                                                                                                                                                                                                                match __v_154.as_canonical_u64() {
+                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __v_157: G = __loaded[0];
+                                                                                                                                                                                                                    let __v_158: G = __loaded[1];
+                                                                                                                                                                                                                    let __v_159: G = __loaded[2];
+                                                                                                                                                                                                                    match __v_157.as_canonical_u64() {
+                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __v_160: G = __loaded[0];
+                                                                                                                                                                                                                        let __v_161: G = __loaded[1];
+                                                                                                                                                                                                                        let __v_162: G = __loaded[2];
+                                                                                                                                                                                                                        match __v_160.as_canonical_u64() {
+                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __v_163: G = __loaded[0];
+                                                                                                                                                                                                                            let __v_164: G = __loaded[1];
+                                                                                                                                                                                                                            let __v_165: G = __loaded[2];
+                                                                                                                                                                                                                            match __v_163.as_canonical_u64() {
+                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __v_166: G = __loaded[0];
+                                                                                                                                                                                                                                let __v_167: G = __loaded[1];
+                                                                                                                                                                                                                                let __v_168: G = __loaded[2];
+                                                                                                                                                                                                                                match __v_166.as_canonical_u64() {
+                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __v_169: G = __loaded[0];
+                                                                                                                                                                                                                                    let __v_170: G = __loaded[1];
+                                                                                                                                                                                                                                    let __v_171: G = __loaded[2];
+                                                                                                                                                                                                                                    match __v_169.as_canonical_u64() {
+                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __v_172: G = __loaded[0];
+                                                                                                                                                                                                                                        let __v_173: G = __loaded[1];
+                                                                                                                                                                                                                                        let __v_174: G = __loaded[2];
+                                                                                                                                                                                                                                        match __v_172.as_canonical_u64() {
+                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __v_175: G = __loaded[0];
+                                                                                                                                                                                                                                            let __v_176: G = __loaded[1];
+                                                                                                                                                                                                                                            let __v_177: G = __loaded[2];
+                                                                                                                                                                                                                                            match __v_175.as_canonical_u64() {
+                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __v_178: G = __loaded[0];
+                                                                                                                                                                                                                                                let __v_179: G = __loaded[1];
+                                                                                                                                                                                                                                                let __v_180: G = __loaded[2];
+                                                                                                                                                                                                                                                match __v_178.as_canonical_u64() {
+                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __v_181: G = __loaded[0];
+                                                                                                                                                                                                                                                    let __v_182: G = __loaded[1];
+                                                                                                                                                                                                                                                    let __v_183: G = __loaded[2];
+                                                                                                                                                                                                                                                    match __v_181.as_canonical_u64() {
+                                                                                                                                                                                                                                                      0u64 => {
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __v_184: G = __loaded[0];
+                                                                                                                                                                                                                                                        let __v_185: G = __loaded[1];
+                                                                                                                                                                                                                                                        let __v_186: G = __loaded[2];
+                                                                                                                                                                                                                                                        match __v_184.as_canonical_u64() {
+                                                                                                                                                                                                                                                          0u64 => {
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __v_187: G = __loaded[0];
+                                                                                                                                                                                                                                                            let __v_188: G = __loaded[1];
+                                                                                                                                                                                                                                                            let __v_189: G = __loaded[2];
+                                                                                                                                                                                                                                                            match __v_187.as_canonical_u64() {
+                                                                                                                                                                                                                                                              0u64 => {
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __v_190: G = __loaded[0];
+                                                                                                                                                                                                                                                                let __v_191: G = __loaded[1];
+                                                                                                                                                                                                                                                                let __v_192: G = __loaded[2];
+                                                                                                                                                                                                                                                                match __v_190.as_canonical_u64() {
+                                                                                                                                                                                                                                                                  0u64 => {
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_69] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                                                                                                                                                                                                                                                    return Ok(__ret);
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64()));
+                                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64()));
+                                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64()));
+                                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64()));
+                                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64()));
+                                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64()));
+                                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64()));
+                                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64()));
+                                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64()));
+                                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                                }
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64()));
+                                                                                                                                                                                                                              },
+                                                                                                                                                                                                                            }
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64()));
+                                                                                                                                                                                                                          },
+                                                                                                                                                                                                                        }
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64()));
+                                                                                                                                                                                                                      },
+                                                                                                                                                                                                                    }
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64()));
+                                                                                                                                                                                                                  },
+                                                                                                                                                                                                                }
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64()));
+                                                                                                                                                                                                              },
+                                                                                                                                                                                                            }
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                          _ => {
+                                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64()));
+                                                                                                                                                                                                          },
+                                                                                                                                                                                                        }
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                      _ => {
+                                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64()));
+                                                                                                                                                                                                      },
+                                                                                                                                                                                                    }
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                  _ => {
+                                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64()));
+                                                                                                                                                                                                  },
+                                                                                                                                                                                                }
+                                                                                                                                                                                              },
+                                                                                                                                                                                              _ => {
+                                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64()));
+                                                                                                                                                                                              },
+                                                                                                                                                                                            }
+                                                                                                                                                                                          },
+                                                                                                                                                                                          _ => {
+                                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64()));
+                                                                                                                                                                                          },
+                                                                                                                                                                                        }
+                                                                                                                                                                                      },
+                                                                                                                                                                                      _ => {
+                                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64()));
+                                                                                                                                                                                      },
+                                                                                                                                                                                    }
+                                                                                                                                                                                  },
+                                                                                                                                                                                  _ => {
+                                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64()));
+                                                                                                                                                                                  },
+                                                                                                                                                                                }
+                                                                                                                                                                              },
+                                                                                                                                                                              _ => {
+                                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64()));
+                                                                                                                                                                              },
+                                                                                                                                                                            }
+                                                                                                                                                                          },
+                                                                                                                                                                          _ => {
+                                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                                                                                                                                                          },
+                                                                                                                                                                        }
+                                                                                                                                                                      },
+                                                                                                                                                                      _ => {
+                                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                                                                                                                                                      },
+                                                                                                                                                                    }
+                                                                                                                                                                  },
+                                                                                                                                                                  _ => {
+                                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                                                                                                                                                                  },
+                                                                                                                                                                }
+                                                                                                                                                              },
+                                                                                                                                                              _ => {
+                                                                                                                                                                return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                                                                                                                                                              },
+                                                                                                                                                            }
+                                                                                                                                                          },
+                                                                                                                                                          _ => {
+                                                                                                                                                            return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                                                                                                                                                          },
+                                                                                                                                                        }
+                                                                                                                                                      },
+                                                                                                                                                      _ => {
+                                                                                                                                                        return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                                                                                                                                                      },
+                                                                                                                                                    }
+                                                                                                                                                  },
+                                                                                                                                                  _ => {
+                                                                                                                                                    return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+                                                                                                                                                  },
+                                                                                                                                                }
+                                                                                                                                              },
+                                                                                                                                              _ => {
+                                                                                                                                                return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+                                                                                                                                              },
+                                                                                                                                            }
+                                                                                                                                          },
+                                                                                                                                          _ => {
+                                                                                                                                            return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64()));
+                                                                                                                                          },
+                                                                                                                                        }
+                                                                                                                                      },
+                                                                                                                                      _ => {
+                                                                                                                                        return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64()));
+                                                                                                                                      },
+                                                                                                                                    }
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                  },
+                                                                                                                                }
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
+                                                                                                                              },
+                                                                                                                            }
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
+                                                                                                                          },
+                                                                                                                        }
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
+                                                                                                                      },
+                                                                                                                    }
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
+                                                                                                                  },
+                                                                                                                }
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
+                                                                                                              },
+                                                                                                            }
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
+                                                                                                          },
+                                                                                                        }
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
+                                                                                                      },
+                                                                                                    }
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+                                                                                                  },
+                                                                                                }
+                                                                                              },
+                                                                                              _ => {
+                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
+                                                                                              },
+                                                                                            }
+                                                                                          },
+                                                                                          _ => {
+                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
+                                                                                          },
+                                                                                        }
+                                                                                      },
+                                                                                      _ => {
+                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
+                                                                                      },
+                                                                                    }
+                                                                                  },
+                                                                                  _ => {
+                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
+                                                                                  },
+                                                                                }
+                                                                              },
+                                                                              _ => {
+                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+                                                                              },
+                                                                            }
+                                                                          },
+                                                                          _ => {
+                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
+                                                                          },
+                                                                        }
+                                                                      },
+                                                                      _ => {
+                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
+                                                                      },
+                                                                    }
+                                                                  },
+                                                                  _ => {
+                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
+                                                                  },
+                                                                }
+                                                              },
+                                                              _ => {
+                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
+                                                              },
+                                                            }
+                                                          },
+                                                          _ => {
+                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                                                          },
+                                                        }
+                                                      },
+                                                      _ => {
+                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+                                                      },
+                                                    }
+                                                  },
+                                                  _ => {
+                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_70: usize = 2;
+const IN_70: usize = 2;
+const OUT_70: usize = 1;
+fn aiur_fn_70(
+  inp: [G; IN_70],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_70], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_70] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(0);
+        let __v_3: G = G::from_u64(0);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = (__v_1 - __v_5);
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; 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 { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_70] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_71: usize = 6;
+const IN_71: usize = 6;
+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_71], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __v_9: G = __loaded[0];
+            let __v_10: G = __loaded[1];
+            let __v_11: G = __loaded[2];
+            let __v_12: G = __loaded[3];
+            let __v_13: G = __loaded[4];
+            let __v_14: G = __loaded[5];
+            let __v_15: G = __loaded[6];
+            let __v_16: G = __loaded[7];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    match __v_11.as_canonical_u64() {
+                      0u64 => {
+                        match __v_12.as_canonical_u64() {
+                          0u64 => {
+                            match __v_13.as_canonical_u64() {
+                              0u64 => {
+                                match __v_14.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_15.as_canonical_u64() {
+                                      0u64 => {
+                                        match __v_16.as_canonical_u64() {
+                                          0u64 => {
+                                            let __v_17: G = (__v_6 + __v_7);
+                                            let __v_18: G = (__v_8 + __v_17);
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __v_19: G = __loaded[0];
+                                            let __v_20: G = __loaded[1];
+                                            let __v_21: G = __loaded[2];
+                                            let __v_22: G = __loaded[3];
+                                            let __v_23: G = __loaded[4];
+                                            let __v_24: G = __loaded[5];
+                                            let __v_25: G = __loaded[6];
+                                            let __v_26: G = __loaded[7];
+                                            let __v_27: G = __loaded[8];
+                                            let __v_28: G = __loaded[9];
+                                            let __v_29: G = __loaded[10];
+                                            let __v_30: G = __loaded[11];
+                                            let __v_31: G = __loaded[12];
+                                            let __v_32: G = __loaded[13];
+                                            let __v_33: G = __loaded[14];
+                                            let __v_34: G = __loaded[15];
+                                            let __v_35: G = __loaded[16];
+                                            let __v_36: G = __loaded[17];
+                                            let __v_37: G = __loaded[18];
+                                            let __v_38: G = __loaded[19];
+                                            let __v_39: G = __loaded[20];
+                                            let __v_40: G = __loaded[21];
+                                            let __v_41: G = __loaded[22];
+                                            let __v_42: G = __loaded[23];
+                                            let __v_43: G = __loaded[24];
+                                            let __v_44: G = __loaded[25];
+                                            let __v_45: G = __loaded[26];
+                                            let __v_46: G = __loaded[27];
+                                            let __v_47: G = __loaded[28];
+                                            let __v_48: G = __loaded[29];
+                                            let __v_49: G = __loaded[30];
+                                            let __v_50: G = __loaded[31];
+                                            let __v_51: G = G::from_u64(0);
+                                            let __v_52: G = G::from_u64(0);
+                                            let __v_53: G = G::from_u64(0);
+                                            let __v_54: G = G::from_u64(0);
+                                            let __v_55: G = G::from_u64(0);
+                                            let __v_56: G = G::from_u64(0);
+                                            let __v_57: G = G::from_u64(0);
+                                            let __v_58: G = G::from_u64(0);
+                                            let __v_59: G = G::from_u64(0);
+                                            let __v_60: G = G::from_u64(0);
+                                            let __v_61: G = G::from_u64(0);
+                                            let __v_62: G = G::from_u64(0);
+                                            let __v_63: G = G::from_u64(0);
+                                            let __v_64: G = G::from_u64(0);
+                                            let __v_65: G = G::from_u64(0);
+                                            let __v_66: G = G::from_u64(0);
+                                            let __v_67: G = G::from_u64(0);
+                                            let __v_68: G = G::from_u64(0);
+                                            let __v_69: G = G::from_u64(0);
+                                            let __v_70: G = G::from_u64(0);
+                                            let __v_71: G = G::from_u64(0);
+                                            let __v_72: G = G::from_u64(0);
+                                            let __v_73: G = G::from_u64(0);
+                                            let __v_74: G = G::from_u64(0);
+                                            let __v_75: G = G::from_u64(0);
+                                            let __v_76: G = G::from_u64(0);
+                                            let __v_77: G = G::from_u64(0);
+                                            let __v_78: G = G::from_u64(0);
+                                            let __v_79: G = G::from_u64(0);
+                                            let __v_80: G = G::from_u64(0);
+                                            let __v_81: G = G::from_u64(0);
+                                            let __v_82: G = G::from_u64(0);
+                                            let __v_83: G = G::from_u64(0);
+                                            let __v_84: G = G::from_u64(0);
+                                            let __v_85: G = G::from_u64(0);
+                                            let __v_86: G = G::from_u64(0);
+                                            let __v_87: G = G::from_u64(0);
+                                            let __v_88: G = G::from_u64(0);
+                                            let __v_89: G = G::from_u64(0);
+                                            let __v_90: G = G::from_u64(0);
+                                            let __v_91: G = G::from_u64(0);
+                                            let __v_92: G = G::from_u64(0);
+                                            let __v_93: G = G::from_u64(0);
+                                            let __v_94: G = G::from_u64(0);
+                                            let __v_95: G = G::from_u64(0);
+                                            let __v_96: G = G::from_u64(0);
+                                            let __v_97: G = G::from_u64(0);
+                                            let __v_98: G = G::from_u64(0);
+                                            let __v_99: G = G::from_u64(0);
+                                            let __v_100: G = G::from_u64(0);
+                                            let __v_101: G = G::from_u64(0);
+                                            let __v_102: G = G::from_u64(0);
+                                            let __v_103: G = G::from_u64(0);
+                                            let __v_104: G = G::from_u64(0);
+                                            let __v_105: G = G::from_u64(0);
+                                            let __v_106: G = G::from_u64(0);
+                                            let __v_107: G = G::from_u64(0);
+                                            let __v_108: G = G::from_u64(0);
+                                            let __v_109: G = G::from_u64(0);
+                                            let __v_110: G = G::from_u64(0);
+                                            let __v_111: G = G::from_u64(0);
+                                            let __v_112: G = G::from_u64(0);
+                                            let __v_113: G = G::from_u64(0);
+                                            let __v_114: G = G::from_u64(0);
+                                            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __v_115: G = __loaded[0];
+                                            let __v_116: G = __loaded[1];
+                                            let __v_117: G = __loaded[2];
+                                            let __v_118: G = __loaded[3];
+                                            let __v_119: G = __loaded[4];
+                                            let __v_120: G = __loaded[5];
+                                            let __v_121: G = __loaded[6];
+                                            let __v_122: G = __loaded[7];
+                                            let __v_123: G = G::from_u64(0);
+                                            let __v_124: G = G::from_u64(103);
+                                            let __v_125: G = G::from_u64(230);
+                                            let __v_126: G = G::from_u64(9);
+                                            let __v_127: G = G::from_u64(106);
+                                            let __v_128: G = G::from_u64(133);
+                                            let __v_129: G = G::from_u64(174);
+                                            let __v_130: G = G::from_u64(103);
+                                            let __v_131: G = G::from_u64(187);
+                                            let __v_132: G = G::from_u64(114);
+                                            let __v_133: G = G::from_u64(243);
+                                            let __v_134: G = G::from_u64(110);
+                                            let __v_135: G = G::from_u64(60);
+                                            let __v_136: G = G::from_u64(58);
+                                            let __v_137: G = G::from_u64(245);
+                                            let __v_138: G = G::from_u64(79);
+                                            let __v_139: G = G::from_u64(165);
+                                            let __v_140: G = G::from_u64(0);
+                                            let __v_141: G = G::from_u64(0);
+                                            let __v_142: G = G::from_u64(0);
+                                            let __v_143: G = G::from_u64(0);
+                                            let __v_144: G = G::from_u64(0);
+                                            let __v_145: G = G::from_u64(0);
+                                            let __v_146: G = G::from_u64(0);
+                                            let __v_147: G = G::from_u64(0);
+                                            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_148: G = __r_arr[0];
+                                            let __v_149: G = __r_arr[1];
+                                            let __v_150: G = __r_arr[2];
+                                            let __v_151: G = __r_arr[3];
+                                            let __v_152: G = __r_arr[4];
+                                            let __v_153: G = __r_arr[5];
+                                            let __v_154: G = __r_arr[6];
+                                            let __v_155: G = __r_arr[7];
+                                            let __v_156: G = __r_arr[8];
+                                            let __v_157: G = __r_arr[9];
+                                            let __v_158: G = __r_arr[10];
+                                            let __v_159: G = __r_arr[11];
+                                            let __v_160: G = __r_arr[12];
+                                            let __v_161: G = __r_arr[13];
+                                            let __v_162: G = __r_arr[14];
+                                            let __v_163: G = __r_arr[15];
+                                            let __v_164: G = __r_arr[16];
+                                            let __v_165: G = __r_arr[17];
+                                            let __v_166: G = __r_arr[18];
+                                            let __v_167: G = __r_arr[19];
+                                            let __v_168: G = __r_arr[20];
+                                            let __v_169: G = __r_arr[21];
+                                            let __v_170: G = __r_arr[22];
+                                            let __v_171: G = __r_arr[23];
+                                            let __v_172: G = __r_arr[24];
+                                            let __v_173: G = __r_arr[25];
+                                            let __v_174: G = __r_arr[26];
+                                            let __v_175: G = __r_arr[27];
+                                            let __v_176: G = __r_arr[28];
+                                            let __v_177: G = __r_arr[29];
+                                            let __v_178: G = __r_arr[30];
+                                            let __v_179: G = __r_arr[31];
+                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __ret: [G; OUT_71] = [__v_180];
+                                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                            return Ok(__ret);
+                                          },
+                                          _ => {
+                                            let __ret: [G; OUT_71] = [__v_5];
+                                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                            return Ok(__ret);
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_71] = [__v_5];
+                                        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_71] = [__v_5];
+                                    if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_71] = [__v_5];
+                                if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_71] = [__v_5];
+                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_71] = [__v_5];
+                        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_71] = [__v_5];
+                    if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_71] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_9: G = G::from_u64(0);
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            let __v_13: G = __loaded[3];
+            let __v_14: G = __loaded[4];
+            let __v_15: G = __loaded[5];
+            let __v_16: G = __loaded[6];
+            let __v_17: G = __loaded[7];
+            let __v_18: G = __loaded[8];
+            let __v_19: G = __loaded[9];
+            let __v_20: G = __loaded[10];
+            let __v_21: G = __loaded[11];
+            let __v_22: G = __loaded[12];
+            let __v_23: G = __loaded[13];
+            let __v_24: G = __loaded[14];
+            let __v_25: G = __loaded[15];
+            let __v_26: G = __loaded[16];
+            let __v_27: G = __loaded[17];
+            let __v_28: G = __loaded[18];
+            let __v_29: G = __loaded[19];
+            let __v_30: G = __loaded[20];
+            let __v_31: G = __loaded[21];
+            let __v_32: G = __loaded[22];
+            let __v_33: G = __loaded[23];
+            let __v_34: G = __loaded[24];
+            let __v_35: G = __loaded[25];
+            let __v_36: G = __loaded[26];
+            let __v_37: G = __loaded[27];
+            let __v_38: G = __loaded[28];
+            let __v_39: G = __loaded[29];
+            let __v_40: G = __loaded[30];
+            let __v_41: G = __loaded[31];
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_71] = [__v_42];
+            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_9: G = __loaded[0];
+        let __v_10: G = __loaded[1];
+        let __v_11: G = __loaded[2];
+        let __v_12: G = __loaded[3];
+        let __v_13: G = __loaded[4];
+        let __v_14: G = __loaded[5];
+        let __v_15: G = __loaded[6];
+        let __v_16: G = __loaded[7];
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+        let __v_18: G = (__v_17 * __v_8);
+        let __v_19: G = (__v_2 - __v_1);
+        let __v_20: G = G::from_bool((__v_19 == G::ZERO));
+        let __v_21: G = (__v_20 * __v_6);
+        let __v_22: G = (__v_18 + __v_21);
+        let __v_23: G = (__v_7 + __v_22);
+        let __v_24: G = G::from_u64(64);
+        let __v_25: G = (__v_24 - __v_1);
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; 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 { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; 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 { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __v_37: G = __r_arr[10];
+        let __v_38: G = __r_arr[11];
+        let __v_39: G = __r_arr[12];
+        let __v_40: G = __r_arr[13];
+        let __v_41: G = __r_arr[14];
+        let __v_42: G = __r_arr[15];
+        let __v_43: G = __r_arr[16];
+        let __v_44: G = __r_arr[17];
+        let __v_45: G = __r_arr[18];
+        let __v_46: G = __r_arr[19];
+        let __v_47: G = __r_arr[20];
+        let __v_48: G = __r_arr[21];
+        let __v_49: G = __r_arr[22];
+        let __v_50: G = __r_arr[23];
+        let __v_51: G = __r_arr[24];
+        let __v_52: G = __r_arr[25];
+        let __v_53: G = __r_arr[26];
+        let __v_54: G = __r_arr[27];
+        let __v_55: G = __r_arr[28];
+        let __v_56: G = __r_arr[29];
+        let __v_57: G = __r_arr[30];
+        let __v_58: G = __r_arr[31];
+        let __v_59: G = __r_arr[32];
+        let __v_60: G = __r_arr[33];
+        let __v_61: G = __r_arr[34];
+        let __v_62: G = __r_arr[35];
+        let __v_63: G = __r_arr[36];
+        let __v_64: G = __r_arr[37];
+        let __v_65: G = __r_arr[38];
+        let __v_66: G = __r_arr[39];
+        let __v_67: G = __r_arr[40];
+        let __v_68: G = __r_arr[41];
+        let __v_69: G = __r_arr[42];
+        let __v_70: G = __r_arr[43];
+        let __v_71: G = __r_arr[44];
+        let __v_72: G = __r_arr[45];
+        let __v_73: G = __r_arr[46];
+        let __v_74: G = __r_arr[47];
+        let __v_75: G = __r_arr[48];
+        let __v_76: G = __r_arr[49];
+        let __v_77: G = __r_arr[50];
+        let __v_78: G = __r_arr[51];
+        let __v_79: G = __r_arr[52];
+        let __v_80: G = __r_arr[53];
+        let __v_81: G = __r_arr[54];
+        let __v_82: G = __r_arr[55];
+        let __v_83: G = __r_arr[56];
+        let __v_84: G = __r_arr[57];
+        let __v_85: G = __r_arr[58];
+        let __v_86: G = __r_arr[59];
+        let __v_87: G = __r_arr[60];
+        let __v_88: G = __r_arr[61];
+        let __v_89: G = __r_arr[62];
+        let __v_90: G = __r_arr[63];
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_91: G = __loaded[0];
+        let __v_92: G = __loaded[1];
+        let __v_93: G = __loaded[2];
+        let __v_94: G = __loaded[3];
+        let __v_95: G = __loaded[4];
+        let __v_96: G = __loaded[5];
+        let __v_97: G = __loaded[6];
+        let __v_98: G = __loaded[7];
+        let __v_99: G = __loaded[8];
+        let __v_100: G = __loaded[9];
+        let __v_101: G = __loaded[10];
+        let __v_102: G = __loaded[11];
+        let __v_103: G = __loaded[12];
+        let __v_104: G = __loaded[13];
+        let __v_105: G = __loaded[14];
+        let __v_106: G = __loaded[15];
+        let __v_107: G = __loaded[16];
+        let __v_108: G = __loaded[17];
+        let __v_109: G = __loaded[18];
+        let __v_110: G = __loaded[19];
+        let __v_111: G = __loaded[20];
+        let __v_112: G = __loaded[21];
+        let __v_113: G = __loaded[22];
+        let __v_114: G = __loaded[23];
+        let __v_115: G = __loaded[24];
+        let __v_116: G = __loaded[25];
+        let __v_117: G = __loaded[26];
+        let __v_118: G = __loaded[27];
+        let __v_119: G = __loaded[28];
+        let __v_120: G = __loaded[29];
+        let __v_121: G = __loaded[30];
+        let __v_122: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_123: G = __loaded[0];
+        let __v_124: G = __loaded[1];
+        let __v_125: G = __loaded[2];
+        let __v_126: G = __loaded[3];
+        let __v_127: G = __loaded[4];
+        let __v_128: G = __loaded[5];
+        let __v_129: G = __loaded[6];
+        let __v_130: G = __loaded[7];
+        let __v_131: G = G::from_u64(103);
+        let __v_132: G = G::from_u64(230);
+        let __v_133: G = G::from_u64(9);
+        let __v_134: G = G::from_u64(106);
+        let __v_135: G = G::from_u64(133);
+        let __v_136: G = G::from_u64(174);
+        let __v_137: G = G::from_u64(103);
+        let __v_138: G = G::from_u64(187);
+        let __v_139: G = G::from_u64(114);
+        let __v_140: G = G::from_u64(243);
+        let __v_141: G = G::from_u64(110);
+        let __v_142: G = G::from_u64(60);
+        let __v_143: G = G::from_u64(58);
+        let __v_144: G = G::from_u64(245);
+        let __v_145: G = G::from_u64(79);
+        let __v_146: G = G::from_u64(165);
+        let __v_147: G = G::from_u64(0);
+        let __v_148: G = G::from_u64(0);
+        let __v_149: G = G::from_u64(0);
+        let __v_150: G = G::from_u64(0);
+        let __v_151: G = G::from_u64(0);
+        let __v_152: G = G::from_u64(0);
+        let __v_153: G = G::from_u64(0);
+        let __v_154: G = G::from_u64(0);
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
+        let __v_156: G = __r_arr[1];
+        let __v_157: G = __r_arr[2];
+        let __v_158: G = __r_arr[3];
+        let __v_159: G = __r_arr[4];
+        let __v_160: G = __r_arr[5];
+        let __v_161: G = __r_arr[6];
+        let __v_162: G = __r_arr[7];
+        let __v_163: G = __r_arr[8];
+        let __v_164: G = __r_arr[9];
+        let __v_165: G = __r_arr[10];
+        let __v_166: G = __r_arr[11];
+        let __v_167: G = __r_arr[12];
+        let __v_168: G = __r_arr[13];
+        let __v_169: G = __r_arr[14];
+        let __v_170: G = __r_arr[15];
+        let __v_171: G = __r_arr[16];
+        let __v_172: G = __r_arr[17];
+        let __v_173: G = __r_arr[18];
+        let __v_174: G = __r_arr[19];
+        let __v_175: G = __r_arr[20];
+        let __v_176: G = __r_arr[21];
+        let __v_177: G = __r_arr[22];
+        let __v_178: G = __r_arr[23];
+        let __v_179: G = __r_arr[24];
+        let __v_180: G = __r_arr[25];
+        let __v_181: G = __r_arr[26];
+        let __v_182: G = __r_arr[27];
+        let __v_183: G = __r_arr[28];
+        let __v_184: G = __r_arr[29];
+        let __v_185: G = __r_arr[30];
+        let __v_186: G = __r_arr[31];
+        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_71] = [__v_187];
+        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_72: usize = 6;
+const IN_72: usize = 6;
+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_72], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = G::from_u64(1);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(8);
+    let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; 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 { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __v_11: G = __r_arr[2];
+    let __v_12: G = __r_arr[3];
+    let __v_13: G = __r_arr[4];
+    let __v_14: G = __r_arr[5];
+    let __v_15: G = __r_arr[6];
+    let __v_16: G = __r_arr[7];
+    let __v_17: G = __r_arr[8];
+    let __v_18: G = __r_arr[9];
+    let __v_19: G = __r_arr[10];
+    let __v_20: G = __r_arr[11];
+    let __v_21: G = __r_arr[12];
+    let __v_22: G = __r_arr[13];
+    let __v_23: G = __r_arr[14];
+    let __v_24: G = __r_arr[15];
+    let __v_25: G = __r_arr[16];
+    let __v_26: G = __r_arr[17];
+    let __v_27: G = __r_arr[18];
+    let __v_28: G = __r_arr[19];
+    let __v_29: G = __r_arr[20];
+    let __v_30: G = __r_arr[21];
+    let __v_31: G = __r_arr[22];
+    let __v_32: G = __r_arr[23];
+    let __v_33: G = __r_arr[24];
+    let __v_34: G = __r_arr[25];
+    let __v_35: G = __r_arr[26];
+    let __v_36: G = __r_arr[27];
+    let __v_37: G = __r_arr[28];
+    let __v_38: G = __r_arr[29];
+    let __v_39: G = __r_arr[30];
+    let __v_40: G = __r_arr[31];
+    let __v_41: G = __r_arr[32];
+    let __v_42: G = __r_arr[33];
+    let __v_43: G = __r_arr[34];
+    let __v_44: G = __r_arr[35];
+    let __v_45: G = __r_arr[36];
+    let __v_46: G = __r_arr[37];
+    let __v_47: G = __r_arr[38];
+    let __v_48: G = __r_arr[39];
+    let __v_49: G = __r_arr[40];
+    let __v_50: G = __r_arr[41];
+    let __v_51: G = __r_arr[42];
+    let __v_52: G = __r_arr[43];
+    let __v_53: G = __r_arr[44];
+    let __v_54: G = __r_arr[45];
+    let __v_55: G = __r_arr[46];
+    let __v_56: G = __r_arr[47];
+    let __v_57: G = __r_arr[48];
+    let __v_58: G = __r_arr[49];
+    let __v_59: G = __r_arr[50];
+    let __v_60: G = __r_arr[51];
+    let __v_61: G = __r_arr[52];
+    let __v_62: G = __r_arr[53];
+    let __v_63: G = __r_arr[54];
+    let __v_64: G = __r_arr[55];
+    let __v_65: G = __r_arr[56];
+    let __v_66: G = __r_arr[57];
+    let __v_67: G = __r_arr[58];
+    let __v_68: G = __r_arr[59];
+    let __v_69: G = __r_arr[60];
+    let __v_70: G = __r_arr[61];
+    let __v_71: G = __r_arr[62];
+    let __v_72: G = __r_arr[63];
+    match __v_2.as_canonical_u64() {
+      1023u64 => {
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_75: G = __loaded[1];
+        let __v_76: G = __loaded[2];
+        let __v_77: G = __loaded[3];
+        let __v_78: G = __loaded[4];
+        let __v_79: G = __loaded[5];
+        let __v_80: G = __loaded[6];
+        let __v_81: G = __loaded[7];
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+        let __v_83: G = (__v_73 * __v_82);
+        let __v_84: G = (__v_8 * __v_83);
+        let __v_85: G = (__v_84 + __v_7);
+        let __v_86: G = G::from_u64(103);
+        let __v_87: G = G::from_u64(230);
+        let __v_88: G = G::from_u64(9);
+        let __v_89: G = G::from_u64(106);
+        let __v_90: G = G::from_u64(133);
+        let __v_91: G = G::from_u64(174);
+        let __v_92: G = G::from_u64(103);
+        let __v_93: G = G::from_u64(187);
+        let __v_94: G = G::from_u64(114);
+        let __v_95: G = G::from_u64(243);
+        let __v_96: G = G::from_u64(110);
+        let __v_97: G = G::from_u64(60);
+        let __v_98: G = G::from_u64(58);
+        let __v_99: G = G::from_u64(245);
+        let __v_100: G = G::from_u64(79);
+        let __v_101: G = G::from_u64(165);
+        let __v_102: G = G::from_u64(127);
+        let __v_103: G = G::from_u64(82);
+        let __v_104: G = G::from_u64(14);
+        let __v_105: G = G::from_u64(81);
+        let __v_106: G = G::from_u64(140);
+        let __v_107: G = G::from_u64(104);
+        let __v_108: G = G::from_u64(5);
+        let __v_109: G = G::from_u64(155);
+        let __v_110: G = G::from_u64(171);
+        let __v_111: G = G::from_u64(217);
+        let __v_112: G = G::from_u64(131);
+        let __v_113: G = G::from_u64(31);
+        let __v_114: G = G::from_u64(25);
+        let __v_115: G = G::from_u64(205);
+        let __v_116: G = G::from_u64(224);
+        let __v_117: G = G::from_u64(91);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_118: G = __loaded[0];
+        let __v_119: G = __loaded[1];
+        let __v_120: G = __loaded[2];
+        let __v_121: G = __loaded[3];
+        let __v_122: G = __loaded[4];
+        let __v_123: G = __loaded[5];
+        let __v_124: G = __loaded[6];
+        let __v_125: G = __loaded[7];
+        let __v_126: G = __loaded[8];
+        let __v_127: G = __loaded[9];
+        let __v_128: G = __loaded[10];
+        let __v_129: G = __loaded[11];
+        let __v_130: G = __loaded[12];
+        let __v_131: G = __loaded[13];
+        let __v_132: G = __loaded[14];
+        let __v_133: G = __loaded[15];
+        let __v_134: G = __loaded[16];
+        let __v_135: G = __loaded[17];
+        let __v_136: G = __loaded[18];
+        let __v_137: G = __loaded[19];
+        let __v_138: G = __loaded[20];
+        let __v_139: G = __loaded[21];
+        let __v_140: G = __loaded[22];
+        let __v_141: G = __loaded[23];
+        let __v_142: G = __loaded[24];
+        let __v_143: G = __loaded[25];
+        let __v_144: G = __loaded[26];
+        let __v_145: G = __loaded[27];
+        let __v_146: G = __loaded[28];
+        let __v_147: G = __loaded[29];
+        let __v_148: G = __loaded[30];
+        let __v_149: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_150: G = __loaded[0];
+        let __v_151: G = __loaded[1];
+        let __v_152: G = __loaded[2];
+        let __v_153: G = __loaded[3];
+        let __v_154: G = __loaded[4];
+        let __v_155: G = __loaded[5];
+        let __v_156: G = __loaded[6];
+        let __v_157: G = __loaded[7];
+        let __v_158: G = G::from_u64(64);
+        let __v_159: G = G::from_u64(103);
+        let __v_160: G = G::from_u64(230);
+        let __v_161: G = G::from_u64(9);
+        let __v_162: G = G::from_u64(106);
+        let __v_163: G = G::from_u64(133);
+        let __v_164: G = G::from_u64(174);
+        let __v_165: G = G::from_u64(103);
+        let __v_166: G = G::from_u64(187);
+        let __v_167: G = G::from_u64(114);
+        let __v_168: G = G::from_u64(243);
+        let __v_169: G = G::from_u64(110);
+        let __v_170: G = G::from_u64(60);
+        let __v_171: G = G::from_u64(58);
+        let __v_172: G = G::from_u64(245);
+        let __v_173: G = G::from_u64(79);
+        let __v_174: G = G::from_u64(165);
+        let __v_175: G = G::from_u64(0);
+        let __v_176: G = G::from_u64(0);
+        let __v_177: G = G::from_u64(0);
+        let __v_178: G = G::from_u64(0);
+        let __v_179: G = G::from_u64(0);
+        let __v_180: G = G::from_u64(0);
+        let __v_181: G = G::from_u64(0);
+        let __v_182: G = G::from_u64(0);
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_183: G = __r_arr[0];
+        let __v_184: G = __r_arr[1];
+        let __v_185: G = __r_arr[2];
+        let __v_186: G = __r_arr[3];
+        let __v_187: G = __r_arr[4];
+        let __v_188: G = __r_arr[5];
+        let __v_189: G = __r_arr[6];
+        let __v_190: G = __r_arr[7];
+        let __v_191: G = __r_arr[8];
+        let __v_192: G = __r_arr[9];
+        let __v_193: G = __r_arr[10];
+        let __v_194: G = __r_arr[11];
+        let __v_195: G = __r_arr[12];
+        let __v_196: G = __r_arr[13];
+        let __v_197: G = __r_arr[14];
+        let __v_198: G = __r_arr[15];
+        let __v_199: G = __r_arr[16];
+        let __v_200: G = __r_arr[17];
+        let __v_201: G = __r_arr[18];
+        let __v_202: G = __r_arr[19];
+        let __v_203: G = __r_arr[20];
+        let __v_204: G = __r_arr[21];
+        let __v_205: G = __r_arr[22];
+        let __v_206: G = __r_arr[23];
+        let __v_207: G = __r_arr[24];
+        let __v_208: G = __r_arr[25];
+        let __v_209: G = __r_arr[26];
+        let __v_210: G = __r_arr[27];
+        let __v_211: G = __r_arr[28];
+        let __v_212: G = __r_arr[29];
+        let __v_213: G = __r_arr[30];
+        let __v_214: G = __r_arr[31];
+        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_216: G = G::from_u64(1);
+        let __v_217: G = G::from_u64(1);
+        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_219: G = G::from_u64(0);
+        let __v_220: G = G::from_u64(0);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_221: G = __loaded[0];
+        let __v_222: G = __loaded[1];
+        let __v_223: G = __loaded[2];
+        let __v_224: G = __loaded[3];
+        let __v_225: G = __loaded[4];
+        let __v_226: G = __loaded[5];
+        let __v_227: G = __loaded[6];
+        let __v_228: G = __loaded[7];
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[12].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } };
+        let __v_229: G = __r_arr[0];
+        let __v_230: G = __r_arr[1];
+        let __v_231: G = __r_arr[2];
+        let __v_232: G = __r_arr[3];
+        let __v_233: G = __r_arr[4];
+        let __v_234: G = __r_arr[5];
+        let __v_235: G = __r_arr[6];
+        let __v_236: G = __r_arr[7];
+        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_239: G = __r_arr[0];
+        let __ret: [G; OUT_72] = [__v_239];
+        if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+        let __v_74: G = (__v_73 * __v_7);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_77: G = __loaded[1];
+        let __v_78: G = __loaded[2];
+        let __v_79: G = __loaded[3];
+        let __v_80: G = __loaded[4];
+        let __v_81: G = __loaded[5];
+        let __v_82: G = __loaded[6];
+        let __v_83: G = __loaded[7];
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_84: G = __r_arr[0];
+        let __v_85: G = (__v_84 * __v_8);
+        let __v_86: G = (__v_75 * __v_85);
+        let __v_87: G = G::from_u64(63);
+        let __v_88: G = (__v_2 - __v_87);
+        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+        let __v_90: G = (__v_89 * __v_6);
+        let __v_91: G = (__v_86 + __v_90);
+        let __v_92: G = (__v_74 + __v_91);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_93: G = __loaded[0];
+        let __v_94: G = __loaded[1];
+        let __v_95: G = __loaded[2];
+        let __v_96: G = __loaded[3];
+        let __v_97: G = __loaded[4];
+        let __v_98: G = __loaded[5];
+        let __v_99: G = __loaded[6];
+        let __v_100: G = __loaded[7];
+        let __v_101: G = __loaded[8];
+        let __v_102: G = __loaded[9];
+        let __v_103: G = __loaded[10];
+        let __v_104: G = __loaded[11];
+        let __v_105: G = __loaded[12];
+        let __v_106: G = __loaded[13];
+        let __v_107: G = __loaded[14];
+        let __v_108: G = __loaded[15];
+        let __v_109: G = __loaded[16];
+        let __v_110: G = __loaded[17];
+        let __v_111: G = __loaded[18];
+        let __v_112: G = __loaded[19];
+        let __v_113: G = __loaded[20];
+        let __v_114: G = __loaded[21];
+        let __v_115: G = __loaded[22];
+        let __v_116: G = __loaded[23];
+        let __v_117: G = __loaded[24];
+        let __v_118: G = __loaded[25];
+        let __v_119: G = __loaded[26];
+        let __v_120: G = __loaded[27];
+        let __v_121: G = __loaded[28];
+        let __v_122: G = __loaded[29];
+        let __v_123: G = __loaded[30];
+        let __v_124: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_125: G = __loaded[0];
+        let __v_126: G = __loaded[1];
+        let __v_127: G = __loaded[2];
+        let __v_128: G = __loaded[3];
+        let __v_129: G = __loaded[4];
+        let __v_130: G = __loaded[5];
+        let __v_131: G = __loaded[6];
+        let __v_132: G = __loaded[7];
+        let __v_133: G = G::from_u64(64);
+        let __v_134: G = G::from_u64(103);
+        let __v_135: G = G::from_u64(230);
+        let __v_136: G = G::from_u64(9);
+        let __v_137: G = G::from_u64(106);
+        let __v_138: G = G::from_u64(133);
+        let __v_139: G = G::from_u64(174);
+        let __v_140: G = G::from_u64(103);
+        let __v_141: G = G::from_u64(187);
+        let __v_142: G = G::from_u64(114);
+        let __v_143: G = G::from_u64(243);
+        let __v_144: G = G::from_u64(110);
+        let __v_145: G = G::from_u64(60);
+        let __v_146: G = G::from_u64(58);
+        let __v_147: G = G::from_u64(245);
+        let __v_148: G = G::from_u64(79);
+        let __v_149: G = G::from_u64(165);
+        let __v_150: G = G::from_u64(0);
+        let __v_151: G = G::from_u64(0);
+        let __v_152: G = G::from_u64(0);
+        let __v_153: G = G::from_u64(0);
+        let __v_154: G = G::from_u64(0);
+        let __v_155: G = G::from_u64(0);
+        let __v_156: G = G::from_u64(0);
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_157: G = __r_arr[0];
+        let __v_158: G = __r_arr[1];
+        let __v_159: G = __r_arr[2];
+        let __v_160: G = __r_arr[3];
+        let __v_161: G = __r_arr[4];
+        let __v_162: G = __r_arr[5];
+        let __v_163: G = __r_arr[6];
+        let __v_164: G = __r_arr[7];
+        let __v_165: G = __r_arr[8];
+        let __v_166: G = __r_arr[9];
+        let __v_167: G = __r_arr[10];
+        let __v_168: G = __r_arr[11];
+        let __v_169: G = __r_arr[12];
+        let __v_170: G = __r_arr[13];
+        let __v_171: G = __r_arr[14];
+        let __v_172: G = __r_arr[15];
+        let __v_173: G = __r_arr[16];
+        let __v_174: G = __r_arr[17];
+        let __v_175: G = __r_arr[18];
+        let __v_176: G = __r_arr[19];
+        let __v_177: G = __r_arr[20];
+        let __v_178: G = __r_arr[21];
+        let __v_179: G = __r_arr[22];
+        let __v_180: G = __r_arr[23];
+        let __v_181: G = __r_arr[24];
+        let __v_182: G = __r_arr[25];
+        let __v_183: G = __r_arr[26];
+        let __v_184: G = __r_arr[27];
+        let __v_185: G = __r_arr[28];
+        let __v_186: G = __r_arr[29];
+        let __v_187: G = __r_arr[30];
+        let __v_188: G = __r_arr[31];
+        let __v_189: G = G::from_u64(1);
+        let __v_190: G = G::from_u64(1);
+        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_192: G = G::from_u64(0);
+        let __v_193: G = G::from_u64(1);
+        let __v_194: G = (__v_2 + __v_193);
+        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_196: G = __r_arr[0];
+        let __ret: [G; OUT_72] = [__v_196];
+        if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_73: usize = 24;
+const IN_73: usize = 24;
+const OUT_73: usize = 16;
+fn aiur_fn_73(
+  inp: [G; IN_73],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_73], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_24: G = G::from_u8(__u32_bytes[0]);
+    let __v_25: G = G::from_u8(__u32_bytes[1]);
+    let __v_26: G = G::from_u8(__u32_bytes[2]);
+    let __v_27: G = G::from_u8(__u32_bytes[3]);
+    let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = (__v_28 - __v_29);
+    let __v_31: G = G::from_u64(2);
+    let __v_32: G = (__v_28 - __v_31);
+    let __v_33: G = (__v_30 * __v_32);
+    let __v_34: G = (__v_28 * __v_33);
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) };
+    let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) };
+    let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) };
+    let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) };
+    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_40: G = G::from_u8(__u32_bytes[0]);
+    let __v_41: G = G::from_u8(__u32_bytes[1]);
+    let __v_42: G = G::from_u8(__u32_bytes[2]);
+    let __v_43: G = G::from_u8(__u32_bytes[3]);
+    let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_45: G = (__v_44 * __v_44);
+    if (__v_45 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) };
+    let __v_46: G = __b2_out.0;
+    let __v_47: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) };
+    let __v_48: G = __b2_out.0;
+    let __v_49: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) };
+    let __v_50: G = __b2_out.0;
+    let __v_51: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) };
+    let __v_52: G = __b2_out.0;
+    let __v_53: G = __b2_out.1;
+    let __v_54: G = (__v_48 + __v_51);
+    let __v_55: G = (__v_50 + __v_53);
+    let __v_56: G = (__v_52 + __v_47);
+    let __v_57: G = (__v_46 + __v_49);
+    let __u32_sum: u128 = u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_54.as_canonical_u64() << 0) | (__v_55.as_canonical_u64() << 8) | (__v_56.as_canonical_u64() << 16) | (__v_57.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_58: G = G::from_u8(__u32_bytes[0]);
+    let __v_59: G = G::from_u8(__u32_bytes[1]);
+    let __v_60: G = G::from_u8(__u32_bytes[2]);
+    let __v_61: G = G::from_u8(__u32_bytes[3]);
+    let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_63: G = G::from_u64(1);
+    let __v_64: G = (__v_62 - __v_63);
+    let __v_65: G = G::from_u64(2);
+    let __v_66: G = (__v_62 - __v_65);
+    let __v_67: G = (__v_64 * __v_66);
+    let __v_68: G = (__v_62 * __v_67);
+    let __v_69: G = G::from_u64(0);
+    if (__v_68 != __v_69) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) };
+    let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) };
+    let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) };
+    let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) };
+    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_74: G = G::from_u8(__u32_bytes[0]);
+    let __v_75: G = G::from_u8(__u32_bytes[1]);
+    let __v_76: G = G::from_u8(__u32_bytes[2]);
+    let __v_77: G = G::from_u8(__u32_bytes[3]);
+    let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_74; let __vj = __v_75; 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_76; let __vj = __v_77; 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_79: G = (__v_78 * __v_78);
+    if (__v_79 != __v_78) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) };
+    let __v_80: G = __b2_out.0;
+    let __v_81: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) };
+    let __v_82: G = __b2_out.0;
+    let __v_83: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) };
+    let __v_84: G = __b2_out.0;
+    let __v_85: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) };
+    let __v_86: G = __b2_out.0;
+    let __v_87: G = __b2_out.1;
+    let __v_88: G = (__v_80 + __v_83);
+    let __v_89: G = (__v_82 + __v_85);
+    let __v_90: G = (__v_84 + __v_87);
+    let __v_91: G = (__v_86 + __v_81);
+    let __ret: [G; OUT_73] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
+    if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_74: usize = 128;
+const IN_74: usize = 128;
+const OUT_74: usize = 128;
+fn aiur_fn_74(
+  inp: [G; IN_74],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_74], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = inp[106];
+    let __v_107: G = inp[107];
+    let __v_108: G = inp[108];
+    let __v_109: G = inp[109];
+    let __v_110: G = inp[110];
+    let __v_111: G = inp[111];
+    let __v_112: G = inp[112];
+    let __v_113: G = inp[113];
+    let __v_114: G = inp[114];
+    let __v_115: G = inp[115];
+    let __v_116: G = inp[116];
+    let __v_117: G = inp[117];
+    let __v_118: G = inp[118];
+    let __v_119: G = inp[119];
+    let __v_120: G = inp[120];
+    let __v_121: G = inp[121];
+    let __v_122: G = inp[122];
+    let __v_123: G = inp[123];
+    let __v_124: G = inp[124];
+    let __v_125: G = inp[125];
+    let __v_126: G = inp[126];
+    let __v_127: G = inp[127];
+    let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_128: G = G::from_u8(__u32_bytes[0]);
+    let __v_129: G = G::from_u8(__u32_bytes[1]);
+    let __v_130: G = G::from_u8(__u32_bytes[2]);
+    let __v_131: G = G::from_u8(__u32_bytes[3]);
+    let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_128; let __vj = __v_129; 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_130; let __vj = __v_131; 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_133: G = G::from_u64(1);
+    let __v_134: G = (__v_132 - __v_133);
+    let __v_135: G = G::from_u64(2);
+    let __v_136: G = (__v_132 - __v_135);
+    let __v_137: G = (__v_134 * __v_136);
+    let __v_138: G = (__v_132 * __v_137);
+    let __v_139: G = G::from_u64(0);
+    if (__v_138 != __v_139) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) };
+    let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
+    let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
+    let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
+    let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_144: G = G::from_u8(__u32_bytes[0]);
+    let __v_145: G = G::from_u8(__u32_bytes[1]);
+    let __v_146: G = G::from_u8(__u32_bytes[2]);
+    let __v_147: G = G::from_u8(__u32_bytes[3]);
+    let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_144; let __vj = __v_145; 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_146; let __vj = __v_147; 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_149: G = (__v_148 * __v_148);
+    if (__v_149 != __v_148) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) };
+    let __v_150: G = __b2_out.0;
+    let __v_151: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
+    let __v_152: G = __b2_out.0;
+    let __v_153: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
+    let __v_154: G = __b2_out.0;
+    let __v_155: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
+    let __v_156: G = __b2_out.0;
+    let __v_157: G = __b2_out.1;
+    let __v_158: G = (__v_152 + __v_155);
+    let __v_159: G = (__v_154 + __v_157);
+    let __v_160: G = (__v_156 + __v_151);
+    let __v_161: G = (__v_150 + __v_153);
+    let __u32_sum: u128 = u128::from(((__v_128.as_canonical_u64() << 0) | (__v_129.as_canonical_u64() << 8) | (__v_130.as_canonical_u64() << 16) | (__v_131.as_canonical_u64() << 24))) + u128::from(((__v_158.as_canonical_u64() << 0) | (__v_159.as_canonical_u64() << 8) | (__v_160.as_canonical_u64() << 16) | (__v_161.as_canonical_u64() << 24))) + u128::from(((__v_68.as_canonical_u64() << 0) | (__v_69.as_canonical_u64() << 8) | (__v_70.as_canonical_u64() << 16) | (__v_71.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_162: G = G::from_u8(__u32_bytes[0]);
+    let __v_163: G = G::from_u8(__u32_bytes[1]);
+    let __v_164: G = G::from_u8(__u32_bytes[2]);
+    let __v_165: G = G::from_u8(__u32_bytes[3]);
+    let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_162; let __vj = __v_163; 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_164; let __vj = __v_165; 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_167: G = G::from_u64(1);
+    let __v_168: G = (__v_166 - __v_167);
+    let __v_169: G = G::from_u64(2);
+    let __v_170: G = (__v_166 - __v_169);
+    let __v_171: G = (__v_168 * __v_170);
+    let __v_172: G = (__v_166 * __v_171);
+    let __v_173: G = G::from_u64(0);
+    if (__v_172 != __v_173) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) };
+    let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
+    let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) };
+    let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
+    let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_178: G = G::from_u8(__u32_bytes[0]);
+    let __v_179: G = G::from_u8(__u32_bytes[1]);
+    let __v_180: G = G::from_u8(__u32_bytes[2]);
+    let __v_181: G = G::from_u8(__u32_bytes[3]);
+    let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_178; let __vj = __v_179; 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_180; let __vj = __v_181; 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_183: G = (__v_182 * __v_182);
+    if (__v_183 != __v_182) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) };
+    let __v_184: G = __b2_out.0;
+    let __v_185: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
+    let __v_186: G = __b2_out.0;
+    let __v_187: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
+    let __v_188: G = __b2_out.0;
+    let __v_189: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
+    let __v_190: G = __b2_out.0;
+    let __v_191: G = __b2_out.1;
+    let __v_192: G = (__v_184 + __v_187);
+    let __v_193: G = (__v_186 + __v_189);
+    let __v_194: G = (__v_188 + __v_191);
+    let __v_195: G = (__v_190 + __v_185);
+    let __u32_sum: u128 = u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_20.as_canonical_u64() << 0) | (__v_21.as_canonical_u64() << 8) | (__v_22.as_canonical_u64() << 16) | (__v_23.as_canonical_u64() << 24))) + u128::from(((__v_72.as_canonical_u64() << 0) | (__v_73.as_canonical_u64() << 8) | (__v_74.as_canonical_u64() << 16) | (__v_75.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_196: G = G::from_u8(__u32_bytes[0]);
+    let __v_197: G = G::from_u8(__u32_bytes[1]);
+    let __v_198: G = G::from_u8(__u32_bytes[2]);
+    let __v_199: G = G::from_u8(__u32_bytes[3]);
+    let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_196; let __vj = __v_197; 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_198; let __vj = __v_199; 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_201: G = G::from_u64(1);
+    let __v_202: G = (__v_200 - __v_201);
+    let __v_203: G = G::from_u64(2);
+    let __v_204: G = (__v_200 - __v_203);
+    let __v_205: G = (__v_202 * __v_204);
+    let __v_206: G = (__v_200 * __v_205);
+    let __v_207: G = G::from_u64(0);
+    if (__v_206 != __v_207) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) };
+    let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
+    let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
+    let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
+    let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_212: G = G::from_u8(__u32_bytes[0]);
+    let __v_213: G = G::from_u8(__u32_bytes[1]);
+    let __v_214: G = G::from_u8(__u32_bytes[2]);
+    let __v_215: G = G::from_u8(__u32_bytes[3]);
+    let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_212; let __vj = __v_213; 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_214; let __vj = __v_215; 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_217: G = (__v_216 * __v_216);
+    if (__v_217 != __v_216) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) };
+    let __v_218: G = __b2_out.0;
+    let __v_219: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
+    let __v_220: G = __b2_out.0;
+    let __v_221: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
+    let __v_222: G = __b2_out.0;
+    let __v_223: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
+    let __v_224: G = __b2_out.0;
+    let __v_225: G = __b2_out.1;
+    let __v_226: G = (__v_220 + __v_223);
+    let __v_227: G = (__v_222 + __v_225);
+    let __v_228: G = (__v_224 + __v_219);
+    let __v_229: G = (__v_218 + __v_221);
+    let __u32_sum: u128 = u128::from(((__v_196.as_canonical_u64() << 0) | (__v_197.as_canonical_u64() << 8) | (__v_198.as_canonical_u64() << 16) | (__v_199.as_canonical_u64() << 24))) + u128::from(((__v_226.as_canonical_u64() << 0) | (__v_227.as_canonical_u64() << 8) | (__v_228.as_canonical_u64() << 16) | (__v_229.as_canonical_u64() << 24))) + u128::from(((__v_76.as_canonical_u64() << 0) | (__v_77.as_canonical_u64() << 8) | (__v_78.as_canonical_u64() << 16) | (__v_79.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_230: G = G::from_u8(__u32_bytes[0]);
+    let __v_231: G = G::from_u8(__u32_bytes[1]);
+    let __v_232: G = G::from_u8(__u32_bytes[2]);
+    let __v_233: G = G::from_u8(__u32_bytes[3]);
+    let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_230; let __vj = __v_231; 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_232; let __vj = __v_233; 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_235: G = G::from_u64(1);
+    let __v_236: G = (__v_234 - __v_235);
+    let __v_237: G = G::from_u64(2);
+    let __v_238: G = (__v_234 - __v_237);
+    let __v_239: G = (__v_236 * __v_238);
+    let __v_240: G = (__v_234 * __v_239);
+    let __v_241: G = G::from_u64(0);
+    if (__v_240 != __v_241) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) };
+    let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
+    let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) };
+    let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
+    let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_246: G = G::from_u8(__u32_bytes[0]);
+    let __v_247: G = G::from_u8(__u32_bytes[1]);
+    let __v_248: G = G::from_u8(__u32_bytes[2]);
+    let __v_249: G = G::from_u8(__u32_bytes[3]);
+    let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_246; let __vj = __v_247; 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_248; let __vj = __v_249; 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_251: G = (__v_250 * __v_250);
+    if (__v_251 != __v_250) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) };
+    let __v_252: G = __b2_out.0;
+    let __v_253: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
+    let __v_254: G = __b2_out.0;
+    let __v_255: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
+    let __v_256: G = __b2_out.0;
+    let __v_257: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
+    let __v_258: G = __b2_out.0;
+    let __v_259: G = __b2_out.1;
+    let __v_260: G = (__v_252 + __v_255);
+    let __v_261: G = (__v_254 + __v_257);
+    let __v_262: G = (__v_256 + __v_259);
+    let __v_263: G = (__v_258 + __v_253);
+    let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_24.as_canonical_u64() << 0) | (__v_25.as_canonical_u64() << 8) | (__v_26.as_canonical_u64() << 16) | (__v_27.as_canonical_u64() << 24))) + u128::from(((__v_80.as_canonical_u64() << 0) | (__v_81.as_canonical_u64() << 8) | (__v_82.as_canonical_u64() << 16) | (__v_83.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_264: G = G::from_u8(__u32_bytes[0]);
+    let __v_265: G = G::from_u8(__u32_bytes[1]);
+    let __v_266: G = G::from_u8(__u32_bytes[2]);
+    let __v_267: G = G::from_u8(__u32_bytes[3]);
+    let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_264; let __vj = __v_265; 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_266; let __vj = __v_267; 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_269: G = G::from_u64(1);
+    let __v_270: G = (__v_268 - __v_269);
+    let __v_271: G = G::from_u64(2);
+    let __v_272: G = (__v_268 - __v_271);
+    let __v_273: G = (__v_270 * __v_272);
+    let __v_274: G = (__v_268 * __v_273);
+    let __v_275: G = G::from_u64(0);
+    if (__v_274 != __v_275) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) };
+    let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
+    let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
+    let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
+    let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_280: G = G::from_u8(__u32_bytes[0]);
+    let __v_281: G = G::from_u8(__u32_bytes[1]);
+    let __v_282: G = G::from_u8(__u32_bytes[2]);
+    let __v_283: G = G::from_u8(__u32_bytes[3]);
+    let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_280; let __vj = __v_281; 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_282; let __vj = __v_283; 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_285: G = (__v_284 * __v_284);
+    if (__v_285 != __v_284) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) };
+    let __v_286: G = __b2_out.0;
+    let __v_287: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
+    let __v_288: G = __b2_out.0;
+    let __v_289: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
+    let __v_290: G = __b2_out.0;
+    let __v_291: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
+    let __v_292: G = __b2_out.0;
+    let __v_293: G = __b2_out.1;
+    let __v_294: G = (__v_288 + __v_291);
+    let __v_295: G = (__v_290 + __v_293);
+    let __v_296: G = (__v_292 + __v_287);
+    let __v_297: G = (__v_286 + __v_289);
+    let __u32_sum: u128 = u128::from(((__v_264.as_canonical_u64() << 0) | (__v_265.as_canonical_u64() << 8) | (__v_266.as_canonical_u64() << 16) | (__v_267.as_canonical_u64() << 24))) + u128::from(((__v_294.as_canonical_u64() << 0) | (__v_295.as_canonical_u64() << 8) | (__v_296.as_canonical_u64() << 16) | (__v_297.as_canonical_u64() << 24))) + u128::from(((__v_84.as_canonical_u64() << 0) | (__v_85.as_canonical_u64() << 8) | (__v_86.as_canonical_u64() << 16) | (__v_87.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_298: G = G::from_u8(__u32_bytes[0]);
+    let __v_299: G = G::from_u8(__u32_bytes[1]);
+    let __v_300: G = G::from_u8(__u32_bytes[2]);
+    let __v_301: G = G::from_u8(__u32_bytes[3]);
+    let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_298; let __vj = __v_299; 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_300; let __vj = __v_301; 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_303: G = G::from_u64(1);
+    let __v_304: G = (__v_302 - __v_303);
+    let __v_305: G = G::from_u64(2);
+    let __v_306: G = (__v_302 - __v_305);
+    let __v_307: G = (__v_304 * __v_306);
+    let __v_308: G = (__v_302 * __v_307);
+    let __v_309: G = G::from_u64(0);
+    if (__v_308 != __v_309) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) };
+    let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
+    let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) };
+    let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
+    let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_314: G = G::from_u8(__u32_bytes[0]);
+    let __v_315: G = G::from_u8(__u32_bytes[1]);
+    let __v_316: G = G::from_u8(__u32_bytes[2]);
+    let __v_317: G = G::from_u8(__u32_bytes[3]);
+    let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_314; let __vj = __v_315; 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_316; let __vj = __v_317; 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_319: G = (__v_318 * __v_318);
+    if (__v_319 != __v_318) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) };
+    let __v_320: G = __b2_out.0;
+    let __v_321: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
+    let __v_322: G = __b2_out.0;
+    let __v_323: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
+    let __v_324: G = __b2_out.0;
+    let __v_325: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
+    let __v_326: G = __b2_out.0;
+    let __v_327: G = __b2_out.1;
+    let __v_328: G = (__v_320 + __v_323);
+    let __v_329: G = (__v_322 + __v_325);
+    let __v_330: G = (__v_324 + __v_327);
+    let __v_331: G = (__v_326 + __v_321);
+    let __u32_sum: u128 = u128::from(((__v_12.as_canonical_u64() << 0) | (__v_13.as_canonical_u64() << 8) | (__v_14.as_canonical_u64() << 16) | (__v_15.as_canonical_u64() << 24))) + u128::from(((__v_28.as_canonical_u64() << 0) | (__v_29.as_canonical_u64() << 8) | (__v_30.as_canonical_u64() << 16) | (__v_31.as_canonical_u64() << 24))) + u128::from(((__v_88.as_canonical_u64() << 0) | (__v_89.as_canonical_u64() << 8) | (__v_90.as_canonical_u64() << 16) | (__v_91.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_332: G = G::from_u8(__u32_bytes[0]);
+    let __v_333: G = G::from_u8(__u32_bytes[1]);
+    let __v_334: G = G::from_u8(__u32_bytes[2]);
+    let __v_335: G = G::from_u8(__u32_bytes[3]);
+    let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_332; let __vj = __v_333; 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_334; let __vj = __v_335; 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_337: G = G::from_u64(1);
+    let __v_338: G = (__v_336 - __v_337);
+    let __v_339: G = G::from_u64(2);
+    let __v_340: G = (__v_336 - __v_339);
+    let __v_341: G = (__v_338 * __v_340);
+    let __v_342: G = (__v_336 * __v_341);
+    let __v_343: G = G::from_u64(0);
+    if (__v_342 != __v_343) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) };
+    let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
+    let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
+    let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
+    let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_348: G = G::from_u8(__u32_bytes[0]);
+    let __v_349: G = G::from_u8(__u32_bytes[1]);
+    let __v_350: G = G::from_u8(__u32_bytes[2]);
+    let __v_351: G = G::from_u8(__u32_bytes[3]);
+    let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_348; let __vj = __v_349; 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_350; let __vj = __v_351; 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_353: G = (__v_352 * __v_352);
+    if (__v_353 != __v_352) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) };
+    let __v_354: G = __b2_out.0;
+    let __v_355: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
+    let __v_356: G = __b2_out.0;
+    let __v_357: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
+    let __v_358: G = __b2_out.0;
+    let __v_359: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
+    let __v_360: G = __b2_out.0;
+    let __v_361: G = __b2_out.1;
+    let __v_362: G = (__v_356 + __v_359);
+    let __v_363: G = (__v_358 + __v_361);
+    let __v_364: G = (__v_360 + __v_355);
+    let __v_365: G = (__v_354 + __v_357);
+    let __u32_sum: u128 = u128::from(((__v_332.as_canonical_u64() << 0) | (__v_333.as_canonical_u64() << 8) | (__v_334.as_canonical_u64() << 16) | (__v_335.as_canonical_u64() << 24))) + u128::from(((__v_362.as_canonical_u64() << 0) | (__v_363.as_canonical_u64() << 8) | (__v_364.as_canonical_u64() << 16) | (__v_365.as_canonical_u64() << 24))) + u128::from(((__v_92.as_canonical_u64() << 0) | (__v_93.as_canonical_u64() << 8) | (__v_94.as_canonical_u64() << 16) | (__v_95.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_366: G = G::from_u8(__u32_bytes[0]);
+    let __v_367: G = G::from_u8(__u32_bytes[1]);
+    let __v_368: G = G::from_u8(__u32_bytes[2]);
+    let __v_369: G = G::from_u8(__u32_bytes[3]);
+    let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_366; let __vj = __v_367; 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_368; let __vj = __v_369; 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_371: G = G::from_u64(1);
+    let __v_372: G = (__v_370 - __v_371);
+    let __v_373: G = G::from_u64(2);
+    let __v_374: G = (__v_370 - __v_373);
+    let __v_375: G = (__v_372 * __v_374);
+    let __v_376: G = (__v_370 * __v_375);
+    let __v_377: G = G::from_u64(0);
+    if (__v_376 != __v_377) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) };
+    let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
+    let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) };
+    let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
+    let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_382: G = G::from_u8(__u32_bytes[0]);
+    let __v_383: G = G::from_u8(__u32_bytes[1]);
+    let __v_384: G = G::from_u8(__u32_bytes[2]);
+    let __v_385: G = G::from_u8(__u32_bytes[3]);
+    let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_382; let __vj = __v_383; 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_384; let __vj = __v_385; 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_387: G = (__v_386 * __v_386);
+    if (__v_387 != __v_386) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) };
+    let __v_388: G = __b2_out.0;
+    let __v_389: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
+    let __v_390: G = __b2_out.0;
+    let __v_391: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
+    let __v_392: G = __b2_out.0;
+    let __v_393: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
+    let __v_394: G = __b2_out.0;
+    let __v_395: G = __b2_out.1;
+    let __v_396: G = (__v_388 + __v_391);
+    let __v_397: G = (__v_390 + __v_393);
+    let __v_398: G = (__v_392 + __v_395);
+    let __v_399: G = (__v_394 + __v_389);
+    let __u32_sum: u128 = u128::from(((__v_162.as_canonical_u64() << 0) | (__v_163.as_canonical_u64() << 8) | (__v_164.as_canonical_u64() << 16) | (__v_165.as_canonical_u64() << 24))) + u128::from(((__v_260.as_canonical_u64() << 0) | (__v_261.as_canonical_u64() << 8) | (__v_262.as_canonical_u64() << 16) | (__v_263.as_canonical_u64() << 24))) + u128::from(((__v_96.as_canonical_u64() << 0) | (__v_97.as_canonical_u64() << 8) | (__v_98.as_canonical_u64() << 16) | (__v_99.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_400: G = G::from_u8(__u32_bytes[0]);
+    let __v_401: G = G::from_u8(__u32_bytes[1]);
+    let __v_402: G = G::from_u8(__u32_bytes[2]);
+    let __v_403: G = G::from_u8(__u32_bytes[3]);
+    let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_400; let __vj = __v_401; 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_402; let __vj = __v_403; 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_405: G = G::from_u64(1);
+    let __v_406: G = (__v_404 - __v_405);
+    let __v_407: G = G::from_u64(2);
+    let __v_408: G = (__v_404 - __v_407);
+    let __v_409: G = (__v_406 * __v_408);
+    let __v_410: G = (__v_404 * __v_409);
+    let __v_411: G = G::from_u64(0);
+    if (__v_410 != __v_411) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) };
+    let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
+    let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
+    let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) };
+    let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_416: G = G::from_u8(__u32_bytes[0]);
+    let __v_417: G = G::from_u8(__u32_bytes[1]);
+    let __v_418: G = G::from_u8(__u32_bytes[2]);
+    let __v_419: G = G::from_u8(__u32_bytes[3]);
+    let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_416; let __vj = __v_417; 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_418; let __vj = __v_419; 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_421: G = (__v_420 * __v_420);
+    if (__v_421 != __v_420) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) };
+    let __v_422: G = __b2_out.0;
+    let __v_423: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
+    let __v_424: G = __b2_out.0;
+    let __v_425: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
+    let __v_426: G = __b2_out.0;
+    let __v_427: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
+    let __v_428: G = __b2_out.0;
+    let __v_429: G = __b2_out.1;
+    let __v_430: G = (__v_424 + __v_427);
+    let __v_431: G = (__v_426 + __v_429);
+    let __v_432: G = (__v_428 + __v_423);
+    let __v_433: G = (__v_422 + __v_425);
+    let __u32_sum: u128 = u128::from(((__v_400.as_canonical_u64() << 0) | (__v_401.as_canonical_u64() << 8) | (__v_402.as_canonical_u64() << 16) | (__v_403.as_canonical_u64() << 24))) + u128::from(((__v_430.as_canonical_u64() << 0) | (__v_431.as_canonical_u64() << 8) | (__v_432.as_canonical_u64() << 16) | (__v_433.as_canonical_u64() << 24))) + u128::from(((__v_100.as_canonical_u64() << 0) | (__v_101.as_canonical_u64() << 8) | (__v_102.as_canonical_u64() << 16) | (__v_103.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_434: G = G::from_u8(__u32_bytes[0]);
+    let __v_435: G = G::from_u8(__u32_bytes[1]);
+    let __v_436: G = G::from_u8(__u32_bytes[2]);
+    let __v_437: G = G::from_u8(__u32_bytes[3]);
+    let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_434; let __vj = __v_435; 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_436; let __vj = __v_437; 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_439: G = G::from_u64(1);
+    let __v_440: G = (__v_438 - __v_439);
+    let __v_441: G = G::from_u64(2);
+    let __v_442: G = (__v_438 - __v_441);
+    let __v_443: G = (__v_440 * __v_442);
+    let __v_444: G = (__v_438 * __v_443);
+    let __v_445: G = G::from_u64(0);
+    if (__v_444 != __v_445) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) };
+    let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
+    let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) };
+    let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
+    let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_450: G = G::from_u8(__u32_bytes[0]);
+    let __v_451: G = G::from_u8(__u32_bytes[1]);
+    let __v_452: G = G::from_u8(__u32_bytes[2]);
+    let __v_453: G = G::from_u8(__u32_bytes[3]);
+    let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_450; let __vj = __v_451; 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_452; let __vj = __v_453; 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_455: G = (__v_454 * __v_454);
+    if (__v_455 != __v_454) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) };
+    let __v_456: G = __b2_out.0;
+    let __v_457: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
+    let __v_458: G = __b2_out.0;
+    let __v_459: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
+    let __v_460: G = __b2_out.0;
+    let __v_461: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
+    let __v_462: G = __b2_out.0;
+    let __v_463: G = __b2_out.1;
+    let __v_464: G = (__v_456 + __v_459);
+    let __v_465: G = (__v_458 + __v_461);
+    let __v_466: G = (__v_460 + __v_463);
+    let __v_467: G = (__v_462 + __v_457);
+    let __u32_sum: u128 = u128::from(((__v_230.as_canonical_u64() << 0) | (__v_231.as_canonical_u64() << 8) | (__v_232.as_canonical_u64() << 16) | (__v_233.as_canonical_u64() << 24))) + u128::from(((__v_328.as_canonical_u64() << 0) | (__v_329.as_canonical_u64() << 8) | (__v_330.as_canonical_u64() << 16) | (__v_331.as_canonical_u64() << 24))) + u128::from(((__v_104.as_canonical_u64() << 0) | (__v_105.as_canonical_u64() << 8) | (__v_106.as_canonical_u64() << 16) | (__v_107.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_468: G = G::from_u8(__u32_bytes[0]);
+    let __v_469: G = G::from_u8(__u32_bytes[1]);
+    let __v_470: G = G::from_u8(__u32_bytes[2]);
+    let __v_471: G = G::from_u8(__u32_bytes[3]);
+    let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_468; let __vj = __v_469; 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_470; let __vj = __v_471; 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_473: G = G::from_u64(1);
+    let __v_474: G = (__v_472 - __v_473);
+    let __v_475: G = G::from_u64(2);
+    let __v_476: G = (__v_472 - __v_475);
+    let __v_477: G = (__v_474 * __v_476);
+    let __v_478: G = (__v_472 * __v_477);
+    let __v_479: G = G::from_u64(0);
+    if (__v_478 != __v_479) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) };
+    let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
+    let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
+    let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) };
+    let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_484: G = G::from_u8(__u32_bytes[0]);
+    let __v_485: G = G::from_u8(__u32_bytes[1]);
+    let __v_486: G = G::from_u8(__u32_bytes[2]);
+    let __v_487: G = G::from_u8(__u32_bytes[3]);
+    let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_484; let __vj = __v_485; 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_486; let __vj = __v_487; 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_489: G = (__v_488 * __v_488);
+    if (__v_489 != __v_488) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) };
+    let __v_490: G = __b2_out.0;
+    let __v_491: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
+    let __v_492: G = __b2_out.0;
+    let __v_493: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
+    let __v_494: G = __b2_out.0;
+    let __v_495: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
+    let __v_496: G = __b2_out.0;
+    let __v_497: G = __b2_out.1;
+    let __v_498: G = (__v_492 + __v_495);
+    let __v_499: G = (__v_494 + __v_497);
+    let __v_500: G = (__v_496 + __v_491);
+    let __v_501: G = (__v_490 + __v_493);
+    let __u32_sum: u128 = u128::from(((__v_468.as_canonical_u64() << 0) | (__v_469.as_canonical_u64() << 8) | (__v_470.as_canonical_u64() << 16) | (__v_471.as_canonical_u64() << 24))) + u128::from(((__v_498.as_canonical_u64() << 0) | (__v_499.as_canonical_u64() << 8) | (__v_500.as_canonical_u64() << 16) | (__v_501.as_canonical_u64() << 24))) + u128::from(((__v_108.as_canonical_u64() << 0) | (__v_109.as_canonical_u64() << 8) | (__v_110.as_canonical_u64() << 16) | (__v_111.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_502: G = G::from_u8(__u32_bytes[0]);
+    let __v_503: G = G::from_u8(__u32_bytes[1]);
+    let __v_504: G = G::from_u8(__u32_bytes[2]);
+    let __v_505: G = G::from_u8(__u32_bytes[3]);
+    let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_502; let __vj = __v_503; 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_504; let __vj = __v_505; 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_507: G = G::from_u64(1);
+    let __v_508: G = (__v_506 - __v_507);
+    let __v_509: G = G::from_u64(2);
+    let __v_510: G = (__v_506 - __v_509);
+    let __v_511: G = (__v_508 * __v_510);
+    let __v_512: G = (__v_506 * __v_511);
+    let __v_513: G = G::from_u64(0);
+    if (__v_512 != __v_513) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) };
+    let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
+    let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) };
+    let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
+    let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_518: G = G::from_u8(__u32_bytes[0]);
+    let __v_519: G = G::from_u8(__u32_bytes[1]);
+    let __v_520: G = G::from_u8(__u32_bytes[2]);
+    let __v_521: G = G::from_u8(__u32_bytes[3]);
+    let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_518; let __vj = __v_519; 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_520; let __vj = __v_521; 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_523: G = (__v_522 * __v_522);
+    if (__v_523 != __v_522) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) };
+    let __v_524: G = __b2_out.0;
+    let __v_525: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
+    let __v_526: G = __b2_out.0;
+    let __v_527: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
+    let __v_528: G = __b2_out.0;
+    let __v_529: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
+    let __v_530: G = __b2_out.0;
+    let __v_531: G = __b2_out.1;
+    let __v_532: G = (__v_524 + __v_527);
+    let __v_533: G = (__v_526 + __v_529);
+    let __v_534: G = (__v_528 + __v_531);
+    let __v_535: G = (__v_530 + __v_525);
+    let __u32_sum: u128 = u128::from(((__v_298.as_canonical_u64() << 0) | (__v_299.as_canonical_u64() << 8) | (__v_300.as_canonical_u64() << 16) | (__v_301.as_canonical_u64() << 24))) + u128::from(((__v_396.as_canonical_u64() << 0) | (__v_397.as_canonical_u64() << 8) | (__v_398.as_canonical_u64() << 16) | (__v_399.as_canonical_u64() << 24))) + u128::from(((__v_112.as_canonical_u64() << 0) | (__v_113.as_canonical_u64() << 8) | (__v_114.as_canonical_u64() << 16) | (__v_115.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_536: G = G::from_u8(__u32_bytes[0]);
+    let __v_537: G = G::from_u8(__u32_bytes[1]);
+    let __v_538: G = G::from_u8(__u32_bytes[2]);
+    let __v_539: G = G::from_u8(__u32_bytes[3]);
+    let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_536; let __vj = __v_537; 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_538; let __vj = __v_539; 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_541: G = G::from_u64(1);
+    let __v_542: G = (__v_540 - __v_541);
+    let __v_543: G = G::from_u64(2);
+    let __v_544: G = (__v_540 - __v_543);
+    let __v_545: G = (__v_542 * __v_544);
+    let __v_546: G = (__v_540 * __v_545);
+    let __v_547: G = G::from_u64(0);
+    if (__v_546 != __v_547) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) };
+    let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
+    let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
+    let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) };
+    let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_552: G = G::from_u8(__u32_bytes[0]);
+    let __v_553: G = G::from_u8(__u32_bytes[1]);
+    let __v_554: G = G::from_u8(__u32_bytes[2]);
+    let __v_555: G = G::from_u8(__u32_bytes[3]);
+    let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_552; let __vj = __v_553; 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_554; let __vj = __v_555; 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_557: G = (__v_556 * __v_556);
+    if (__v_557 != __v_556) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) };
+    let __v_558: G = __b2_out.0;
+    let __v_559: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
+    let __v_560: G = __b2_out.0;
+    let __v_561: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
+    let __v_562: G = __b2_out.0;
+    let __v_563: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
+    let __v_564: G = __b2_out.0;
+    let __v_565: G = __b2_out.1;
+    let __v_566: G = (__v_560 + __v_563);
+    let __v_567: G = (__v_562 + __v_565);
+    let __v_568: G = (__v_564 + __v_559);
+    let __v_569: G = (__v_558 + __v_561);
+    let __u32_sum: u128 = u128::from(((__v_536.as_canonical_u64() << 0) | (__v_537.as_canonical_u64() << 8) | (__v_538.as_canonical_u64() << 16) | (__v_539.as_canonical_u64() << 24))) + u128::from(((__v_566.as_canonical_u64() << 0) | (__v_567.as_canonical_u64() << 8) | (__v_568.as_canonical_u64() << 16) | (__v_569.as_canonical_u64() << 24))) + u128::from(((__v_116.as_canonical_u64() << 0) | (__v_117.as_canonical_u64() << 8) | (__v_118.as_canonical_u64() << 16) | (__v_119.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_570: G = G::from_u8(__u32_bytes[0]);
+    let __v_571: G = G::from_u8(__u32_bytes[1]);
+    let __v_572: G = G::from_u8(__u32_bytes[2]);
+    let __v_573: G = G::from_u8(__u32_bytes[3]);
+    let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_570; let __vj = __v_571; 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_572; let __vj = __v_573; 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_575: G = G::from_u64(1);
+    let __v_576: G = (__v_574 - __v_575);
+    let __v_577: G = G::from_u64(2);
+    let __v_578: G = (__v_574 - __v_577);
+    let __v_579: G = (__v_576 * __v_578);
+    let __v_580: G = (__v_574 * __v_579);
+    let __v_581: G = G::from_u64(0);
+    if (__v_580 != __v_581) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) };
+    let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
+    let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) };
+    let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
+    let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_586: G = G::from_u8(__u32_bytes[0]);
+    let __v_587: G = G::from_u8(__u32_bytes[1]);
+    let __v_588: G = G::from_u8(__u32_bytes[2]);
+    let __v_589: G = G::from_u8(__u32_bytes[3]);
+    let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_586; let __vj = __v_587; 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_588; let __vj = __v_589; 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_591: G = (__v_590 * __v_590);
+    if (__v_591 != __v_590) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) };
+    let __v_592: G = __b2_out.0;
+    let __v_593: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
+    let __v_594: G = __b2_out.0;
+    let __v_595: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
+    let __v_596: G = __b2_out.0;
+    let __v_597: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
+    let __v_598: G = __b2_out.0;
+    let __v_599: G = __b2_out.1;
+    let __v_600: G = (__v_592 + __v_595);
+    let __v_601: G = (__v_594 + __v_597);
+    let __v_602: G = (__v_596 + __v_599);
+    let __v_603: G = (__v_598 + __v_593);
+    let __u32_sum: u128 = u128::from(((__v_366.as_canonical_u64() << 0) | (__v_367.as_canonical_u64() << 8) | (__v_368.as_canonical_u64() << 16) | (__v_369.as_canonical_u64() << 24))) + u128::from(((__v_192.as_canonical_u64() << 0) | (__v_193.as_canonical_u64() << 8) | (__v_194.as_canonical_u64() << 16) | (__v_195.as_canonical_u64() << 24))) + u128::from(((__v_120.as_canonical_u64() << 0) | (__v_121.as_canonical_u64() << 8) | (__v_122.as_canonical_u64() << 16) | (__v_123.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_604: G = G::from_u8(__u32_bytes[0]);
+    let __v_605: G = G::from_u8(__u32_bytes[1]);
+    let __v_606: G = G::from_u8(__u32_bytes[2]);
+    let __v_607: G = G::from_u8(__u32_bytes[3]);
+    let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_604; let __vj = __v_605; 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_606; let __vj = __v_607; 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_609: G = G::from_u64(1);
+    let __v_610: G = (__v_608 - __v_609);
+    let __v_611: G = G::from_u64(2);
+    let __v_612: G = (__v_608 - __v_611);
+    let __v_613: G = (__v_610 * __v_612);
+    let __v_614: G = (__v_608 * __v_613);
+    let __v_615: G = G::from_u64(0);
+    if (__v_614 != __v_615) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) };
+    let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
+    let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
+    let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) };
+    let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_620: G = G::from_u8(__u32_bytes[0]);
+    let __v_621: G = G::from_u8(__u32_bytes[1]);
+    let __v_622: G = G::from_u8(__u32_bytes[2]);
+    let __v_623: G = G::from_u8(__u32_bytes[3]);
+    let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_620; let __vj = __v_621; 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_622; let __vj = __v_623; 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_625: G = (__v_624 * __v_624);
+    if (__v_625 != __v_624) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) };
+    let __v_626: G = __b2_out.0;
+    let __v_627: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
+    let __v_628: G = __b2_out.0;
+    let __v_629: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
+    let __v_630: G = __b2_out.0;
+    let __v_631: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
+    let __v_632: G = __b2_out.0;
+    let __v_633: G = __b2_out.1;
+    let __v_634: G = (__v_628 + __v_631);
+    let __v_635: G = (__v_630 + __v_633);
+    let __v_636: G = (__v_632 + __v_627);
+    let __v_637: G = (__v_626 + __v_629);
+    let __u32_sum: u128 = u128::from(((__v_604.as_canonical_u64() << 0) | (__v_605.as_canonical_u64() << 8) | (__v_606.as_canonical_u64() << 16) | (__v_607.as_canonical_u64() << 24))) + u128::from(((__v_634.as_canonical_u64() << 0) | (__v_635.as_canonical_u64() << 8) | (__v_636.as_canonical_u64() << 16) | (__v_637.as_canonical_u64() << 24))) + u128::from(((__v_124.as_canonical_u64() << 0) | (__v_125.as_canonical_u64() << 8) | (__v_126.as_canonical_u64() << 16) | (__v_127.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_638: G = G::from_u8(__u32_bytes[0]);
+    let __v_639: G = G::from_u8(__u32_bytes[1]);
+    let __v_640: G = G::from_u8(__u32_bytes[2]);
+    let __v_641: G = G::from_u8(__u32_bytes[3]);
+    let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_638; let __vj = __v_639; 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_640; let __vj = __v_641; 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_643: G = G::from_u64(1);
+    let __v_644: G = (__v_642 - __v_643);
+    let __v_645: G = G::from_u64(2);
+    let __v_646: G = (__v_642 - __v_645);
+    let __v_647: G = (__v_644 * __v_646);
+    let __v_648: G = (__v_642 * __v_647);
+    let __v_649: G = G::from_u64(0);
+    if (__v_648 != __v_649) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+    }
+    let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) };
+    let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
+    let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) };
+    let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
+    let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24)));
+    let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+    let __v_654: G = G::from_u8(__u32_bytes[0]);
+    let __v_655: G = G::from_u8(__u32_bytes[1]);
+    let __v_656: G = G::from_u8(__u32_bytes[2]);
+    let __v_657: G = G::from_u8(__u32_bytes[3]);
+    let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+    if !unconstrained { let __vi = __v_654; let __vj = __v_655; 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_656; let __vj = __v_657; 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_659: G = (__v_658 * __v_658);
+    if (__v_659 != __v_658) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+    }
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) };
+    let __v_660: G = __b2_out.0;
+    let __v_661: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
+    let __v_662: G = __b2_out.0;
+    let __v_663: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
+    let __v_664: G = __b2_out.0;
+    let __v_665: G = __b2_out.1;
+    let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
+    let __v_666: G = __b2_out.0;
+    let __v_667: G = __b2_out.1;
+    let __v_668: G = (__v_660 + __v_663);
+    let __v_669: G = (__v_662 + __v_665);
+    let __v_670: G = (__v_664 + __v_667);
+    let __v_671: G = (__v_666 + __v_661);
+    let __ret: [G; OUT_74] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
+    if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_75: usize = 106;
+const IN_75: usize = 106;
+const OUT_75: usize = 32;
+fn aiur_fn_75(
+  inp: [G; IN_75],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_75], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = G::from_u64(103);
+    let __v_107: G = G::from_u64(230);
+    let __v_108: G = G::from_u64(9);
+    let __v_109: G = G::from_u64(106);
+    let __v_110: G = G::from_u64(133);
+    let __v_111: G = G::from_u64(174);
+    let __v_112: G = G::from_u64(103);
+    let __v_113: G = G::from_u64(187);
+    let __v_114: G = G::from_u64(114);
+    let __v_115: G = G::from_u64(243);
+    let __v_116: G = G::from_u64(110);
+    let __v_117: G = G::from_u64(60);
+    let __v_118: G = G::from_u64(58);
+    let __v_119: G = G::from_u64(245);
+    let __v_120: G = G::from_u64(79);
+    let __v_121: G = G::from_u64(165);
+    let __v_122: G = G::from_u64(0);
+    let __v_123: G = G::from_u64(0);
+    let __v_124: G = G::from_u64(0);
+    let __v_125: G = G::from_u64(0);
+    let __v_126: G = G::from_u64(0);
+    let __v_127: G = G::from_u64(0);
+    let __v_128: G = G::from_u64(0);
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __v_131: G = __r_arr[2];
+    let __v_132: G = __r_arr[3];
+    let __v_133: G = __r_arr[4];
+    let __v_134: G = __r_arr[5];
+    let __v_135: G = __r_arr[6];
+    let __v_136: G = __r_arr[7];
+    let __v_137: G = __r_arr[8];
+    let __v_138: G = __r_arr[9];
+    let __v_139: G = __r_arr[10];
+    let __v_140: G = __r_arr[11];
+    let __v_141: G = __r_arr[12];
+    let __v_142: G = __r_arr[13];
+    let __v_143: G = __r_arr[14];
+    let __v_144: G = __r_arr[15];
+    let __v_145: G = __r_arr[16];
+    let __v_146: G = __r_arr[17];
+    let __v_147: G = __r_arr[18];
+    let __v_148: G = __r_arr[19];
+    let __v_149: G = __r_arr[20];
+    let __v_150: G = __r_arr[21];
+    let __v_151: G = __r_arr[22];
+    let __v_152: G = __r_arr[23];
+    let __v_153: G = __r_arr[24];
+    let __v_154: G = __r_arr[25];
+    let __v_155: G = __r_arr[26];
+    let __v_156: G = __r_arr[27];
+    let __v_157: G = __r_arr[28];
+    let __v_158: G = __r_arr[29];
+    let __v_159: G = __r_arr[30];
+    let __v_160: G = __r_arr[31];
+    let __ret: [G; OUT_75] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+    if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_76: usize = 129;
+const IN_76: usize = 129;
+const OUT_76: usize = 32;
+fn aiur_fn_76(
+  inp: [G; IN_76],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_76], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = inp[57];
+    let __v_58: G = inp[58];
+    let __v_59: G = inp[59];
+    let __v_60: G = inp[60];
+    let __v_61: G = inp[61];
+    let __v_62: G = inp[62];
+    let __v_63: G = inp[63];
+    let __v_64: G = inp[64];
+    let __v_65: G = inp[65];
+    let __v_66: G = inp[66];
+    let __v_67: G = inp[67];
+    let __v_68: G = inp[68];
+    let __v_69: G = inp[69];
+    let __v_70: G = inp[70];
+    let __v_71: G = inp[71];
+    let __v_72: G = inp[72];
+    let __v_73: G = inp[73];
+    let __v_74: G = inp[74];
+    let __v_75: G = inp[75];
+    let __v_76: G = inp[76];
+    let __v_77: G = inp[77];
+    let __v_78: G = inp[78];
+    let __v_79: G = inp[79];
+    let __v_80: G = inp[80];
+    let __v_81: G = inp[81];
+    let __v_82: G = inp[82];
+    let __v_83: G = inp[83];
+    let __v_84: G = inp[84];
+    let __v_85: G = inp[85];
+    let __v_86: G = inp[86];
+    let __v_87: G = inp[87];
+    let __v_88: G = inp[88];
+    let __v_89: G = inp[89];
+    let __v_90: G = inp[90];
+    let __v_91: G = inp[91];
+    let __v_92: G = inp[92];
+    let __v_93: G = inp[93];
+    let __v_94: G = inp[94];
+    let __v_95: G = inp[95];
+    let __v_96: G = inp[96];
+    let __v_97: G = inp[97];
+    let __v_98: G = inp[98];
+    let __v_99: G = inp[99];
+    let __v_100: G = inp[100];
+    let __v_101: G = inp[101];
+    let __v_102: G = inp[102];
+    let __v_103: G = inp[103];
+    let __v_104: G = inp[104];
+    let __v_105: G = inp[105];
+    let __v_106: G = inp[106];
+    let __v_107: G = inp[107];
+    let __v_108: G = inp[108];
+    let __v_109: G = inp[109];
+    let __v_110: G = inp[110];
+    let __v_111: G = inp[111];
+    let __v_112: G = inp[112];
+    let __v_113: G = inp[113];
+    let __v_114: G = inp[114];
+    let __v_115: G = inp[115];
+    let __v_116: G = inp[116];
+    let __v_117: G = inp[117];
+    let __v_118: G = inp[118];
+    let __v_119: G = inp[119];
+    let __v_120: G = inp[120];
+    let __v_121: G = inp[121];
+    let __v_122: G = inp[122];
+    let __v_123: G = inp[123];
+    let __v_124: G = inp[124];
+    let __v_125: G = inp[125];
+    let __v_126: G = inp[126];
+    let __v_127: G = inp[127];
+    let __v_128: G = inp[128];
+    match __v_0.as_canonical_u64() {
+      7u64 => {
+        let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) };
+        let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) };
+        let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) };
+        let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) };
+        let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) };
+        let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) };
+        let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) };
+        let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) };
+        let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) };
+        let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) };
+        let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) };
+        let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) };
+        let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) };
+        let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) };
+        let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) };
+        let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) };
+        let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) };
+        let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) };
+        let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) };
+        let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) };
+        let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) };
+        let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) };
+        let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) };
+        let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) };
+        let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) };
+        let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) };
+        let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) };
+        let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) };
+        let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) };
+        let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
+        let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
+        let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
+        let __ret: [G; OUT_76] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+        if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __u32_sum: u128 = u128::from(((__v_1.as_canonical_u64() << 0) | (__v_2.as_canonical_u64() << 8) | (__v_3.as_canonical_u64() << 16) | (__v_4.as_canonical_u64() << 24))) + u128::from(((__v_17.as_canonical_u64() << 0) | (__v_18.as_canonical_u64() << 8) | (__v_19.as_canonical_u64() << 16) | (__v_20.as_canonical_u64() << 24))) + u128::from(((__v_65.as_canonical_u64() << 0) | (__v_66.as_canonical_u64() << 8) | (__v_67.as_canonical_u64() << 16) | (__v_68.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_129: G = G::from_u8(__u32_bytes[0]);
+        let __v_130: G = G::from_u8(__u32_bytes[1]);
+        let __v_131: G = G::from_u8(__u32_bytes[2]);
+        let __v_132: G = G::from_u8(__u32_bytes[3]);
+        let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_129; let __vj = __v_130; 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_131; let __vj = __v_132; 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_134: G = G::from_u64(1);
+        let __v_135: G = (__v_133 - __v_134);
+        let __v_136: G = G::from_u64(2);
+        let __v_137: G = (__v_133 - __v_136);
+        let __v_138: G = (__v_135 * __v_137);
+        let __v_139: G = (__v_133 * __v_138);
+        let __v_140: G = G::from_u64(0);
+        if (__v_139 != __v_140) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) };
+        let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) };
+        let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) };
+        let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) };
+        let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_145: G = G::from_u8(__u32_bytes[0]);
+        let __v_146: G = G::from_u8(__u32_bytes[1]);
+        let __v_147: G = G::from_u8(__u32_bytes[2]);
+        let __v_148: G = G::from_u8(__u32_bytes[3]);
+        let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_145; let __vj = __v_146; 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_147; let __vj = __v_148; 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_150: G = (__v_149 * __v_149);
+        if (__v_150 != __v_149) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) };
+        let __v_151: G = __b2_out.0;
+        let __v_152: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) };
+        let __v_153: G = __b2_out.0;
+        let __v_154: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) };
+        let __v_155: G = __b2_out.0;
+        let __v_156: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) };
+        let __v_157: G = __b2_out.0;
+        let __v_158: G = __b2_out.1;
+        let __v_159: G = (__v_153 + __v_156);
+        let __v_160: G = (__v_155 + __v_158);
+        let __v_161: G = (__v_157 + __v_152);
+        let __v_162: G = (__v_151 + __v_154);
+        let __u32_sum: u128 = u128::from(((__v_129.as_canonical_u64() << 0) | (__v_130.as_canonical_u64() << 8) | (__v_131.as_canonical_u64() << 16) | (__v_132.as_canonical_u64() << 24))) + u128::from(((__v_159.as_canonical_u64() << 0) | (__v_160.as_canonical_u64() << 8) | (__v_161.as_canonical_u64() << 16) | (__v_162.as_canonical_u64() << 24))) + u128::from(((__v_69.as_canonical_u64() << 0) | (__v_70.as_canonical_u64() << 8) | (__v_71.as_canonical_u64() << 16) | (__v_72.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_163: G = G::from_u8(__u32_bytes[0]);
+        let __v_164: G = G::from_u8(__u32_bytes[1]);
+        let __v_165: G = G::from_u8(__u32_bytes[2]);
+        let __v_166: G = G::from_u8(__u32_bytes[3]);
+        let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_163; let __vj = __v_164; 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_165; let __vj = __v_166; 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_168: G = G::from_u64(1);
+        let __v_169: G = (__v_167 - __v_168);
+        let __v_170: G = G::from_u64(2);
+        let __v_171: G = (__v_167 - __v_170);
+        let __v_172: G = (__v_169 * __v_171);
+        let __v_173: G = (__v_167 * __v_172);
+        let __v_174: G = G::from_u64(0);
+        if (__v_173 != __v_174) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) };
+        let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) };
+        let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) };
+        let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) };
+        let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_179: G = G::from_u8(__u32_bytes[0]);
+        let __v_180: G = G::from_u8(__u32_bytes[1]);
+        let __v_181: G = G::from_u8(__u32_bytes[2]);
+        let __v_182: G = G::from_u8(__u32_bytes[3]);
+        let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_179; let __vj = __v_180; 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_181; let __vj = __v_182; 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_184: G = (__v_183 * __v_183);
+        if (__v_184 != __v_183) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) };
+        let __v_185: G = __b2_out.0;
+        let __v_186: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) };
+        let __v_187: G = __b2_out.0;
+        let __v_188: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) };
+        let __v_189: G = __b2_out.0;
+        let __v_190: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) };
+        let __v_191: G = __b2_out.0;
+        let __v_192: G = __b2_out.1;
+        let __v_193: G = (__v_185 + __v_188);
+        let __v_194: G = (__v_187 + __v_190);
+        let __v_195: G = (__v_189 + __v_192);
+        let __v_196: G = (__v_191 + __v_186);
+        let __u32_sum: u128 = u128::from(((__v_5.as_canonical_u64() << 0) | (__v_6.as_canonical_u64() << 8) | (__v_7.as_canonical_u64() << 16) | (__v_8.as_canonical_u64() << 24))) + u128::from(((__v_21.as_canonical_u64() << 0) | (__v_22.as_canonical_u64() << 8) | (__v_23.as_canonical_u64() << 16) | (__v_24.as_canonical_u64() << 24))) + u128::from(((__v_73.as_canonical_u64() << 0) | (__v_74.as_canonical_u64() << 8) | (__v_75.as_canonical_u64() << 16) | (__v_76.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_197: G = G::from_u8(__u32_bytes[0]);
+        let __v_198: G = G::from_u8(__u32_bytes[1]);
+        let __v_199: G = G::from_u8(__u32_bytes[2]);
+        let __v_200: G = G::from_u8(__u32_bytes[3]);
+        let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_197; let __vj = __v_198; 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_199; let __vj = __v_200; 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_202: G = G::from_u64(1);
+        let __v_203: G = (__v_201 - __v_202);
+        let __v_204: G = G::from_u64(2);
+        let __v_205: G = (__v_201 - __v_204);
+        let __v_206: G = (__v_203 * __v_205);
+        let __v_207: G = (__v_201 * __v_206);
+        let __v_208: G = G::from_u64(0);
+        if (__v_207 != __v_208) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) };
+        let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) };
+        let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) };
+        let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) };
+        let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_213: G = G::from_u8(__u32_bytes[0]);
+        let __v_214: G = G::from_u8(__u32_bytes[1]);
+        let __v_215: G = G::from_u8(__u32_bytes[2]);
+        let __v_216: G = G::from_u8(__u32_bytes[3]);
+        let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_213; let __vj = __v_214; 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_215; let __vj = __v_216; 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_218: G = (__v_217 * __v_217);
+        if (__v_218 != __v_217) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) };
+        let __v_219: G = __b2_out.0;
+        let __v_220: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) };
+        let __v_221: G = __b2_out.0;
+        let __v_222: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) };
+        let __v_223: G = __b2_out.0;
+        let __v_224: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) };
+        let __v_225: G = __b2_out.0;
+        let __v_226: G = __b2_out.1;
+        let __v_227: G = (__v_221 + __v_224);
+        let __v_228: G = (__v_223 + __v_226);
+        let __v_229: G = (__v_225 + __v_220);
+        let __v_230: G = (__v_219 + __v_222);
+        let __u32_sum: u128 = u128::from(((__v_197.as_canonical_u64() << 0) | (__v_198.as_canonical_u64() << 8) | (__v_199.as_canonical_u64() << 16) | (__v_200.as_canonical_u64() << 24))) + u128::from(((__v_227.as_canonical_u64() << 0) | (__v_228.as_canonical_u64() << 8) | (__v_229.as_canonical_u64() << 16) | (__v_230.as_canonical_u64() << 24))) + u128::from(((__v_77.as_canonical_u64() << 0) | (__v_78.as_canonical_u64() << 8) | (__v_79.as_canonical_u64() << 16) | (__v_80.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_231: G = G::from_u8(__u32_bytes[0]);
+        let __v_232: G = G::from_u8(__u32_bytes[1]);
+        let __v_233: G = G::from_u8(__u32_bytes[2]);
+        let __v_234: G = G::from_u8(__u32_bytes[3]);
+        let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_231; let __vj = __v_232; 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_233; let __vj = __v_234; 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_236: G = G::from_u64(1);
+        let __v_237: G = (__v_235 - __v_236);
+        let __v_238: G = G::from_u64(2);
+        let __v_239: G = (__v_235 - __v_238);
+        let __v_240: G = (__v_237 * __v_239);
+        let __v_241: G = (__v_235 * __v_240);
+        let __v_242: G = G::from_u64(0);
+        if (__v_241 != __v_242) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) };
+        let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) };
+        let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) };
+        let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) };
+        let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_247: G = G::from_u8(__u32_bytes[0]);
+        let __v_248: G = G::from_u8(__u32_bytes[1]);
+        let __v_249: G = G::from_u8(__u32_bytes[2]);
+        let __v_250: G = G::from_u8(__u32_bytes[3]);
+        let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_247; let __vj = __v_248; 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_249; let __vj = __v_250; 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_252: G = (__v_251 * __v_251);
+        if (__v_252 != __v_251) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) };
+        let __v_253: G = __b2_out.0;
+        let __v_254: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) };
+        let __v_255: G = __b2_out.0;
+        let __v_256: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) };
+        let __v_257: G = __b2_out.0;
+        let __v_258: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) };
+        let __v_259: G = __b2_out.0;
+        let __v_260: G = __b2_out.1;
+        let __v_261: G = (__v_253 + __v_256);
+        let __v_262: G = (__v_255 + __v_258);
+        let __v_263: G = (__v_257 + __v_260);
+        let __v_264: G = (__v_259 + __v_254);
+        let __u32_sum: u128 = u128::from(((__v_9.as_canonical_u64() << 0) | (__v_10.as_canonical_u64() << 8) | (__v_11.as_canonical_u64() << 16) | (__v_12.as_canonical_u64() << 24))) + u128::from(((__v_25.as_canonical_u64() << 0) | (__v_26.as_canonical_u64() << 8) | (__v_27.as_canonical_u64() << 16) | (__v_28.as_canonical_u64() << 24))) + u128::from(((__v_81.as_canonical_u64() << 0) | (__v_82.as_canonical_u64() << 8) | (__v_83.as_canonical_u64() << 16) | (__v_84.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_265: G = G::from_u8(__u32_bytes[0]);
+        let __v_266: G = G::from_u8(__u32_bytes[1]);
+        let __v_267: G = G::from_u8(__u32_bytes[2]);
+        let __v_268: G = G::from_u8(__u32_bytes[3]);
+        let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_265; let __vj = __v_266; 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_267; let __vj = __v_268; 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_270: G = G::from_u64(1);
+        let __v_271: G = (__v_269 - __v_270);
+        let __v_272: G = G::from_u64(2);
+        let __v_273: G = (__v_269 - __v_272);
+        let __v_274: G = (__v_271 * __v_273);
+        let __v_275: G = (__v_269 * __v_274);
+        let __v_276: G = G::from_u64(0);
+        if (__v_275 != __v_276) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) };
+        let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) };
+        let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) };
+        let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) };
+        let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_281: G = G::from_u8(__u32_bytes[0]);
+        let __v_282: G = G::from_u8(__u32_bytes[1]);
+        let __v_283: G = G::from_u8(__u32_bytes[2]);
+        let __v_284: G = G::from_u8(__u32_bytes[3]);
+        let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_281; let __vj = __v_282; 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_283; let __vj = __v_284; 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_286: G = (__v_285 * __v_285);
+        if (__v_286 != __v_285) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) };
+        let __v_287: G = __b2_out.0;
+        let __v_288: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) };
+        let __v_289: G = __b2_out.0;
+        let __v_290: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) };
+        let __v_291: G = __b2_out.0;
+        let __v_292: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) };
+        let __v_293: G = __b2_out.0;
+        let __v_294: G = __b2_out.1;
+        let __v_295: G = (__v_289 + __v_292);
+        let __v_296: G = (__v_291 + __v_294);
+        let __v_297: G = (__v_293 + __v_288);
+        let __v_298: G = (__v_287 + __v_290);
+        let __u32_sum: u128 = u128::from(((__v_265.as_canonical_u64() << 0) | (__v_266.as_canonical_u64() << 8) | (__v_267.as_canonical_u64() << 16) | (__v_268.as_canonical_u64() << 24))) + u128::from(((__v_295.as_canonical_u64() << 0) | (__v_296.as_canonical_u64() << 8) | (__v_297.as_canonical_u64() << 16) | (__v_298.as_canonical_u64() << 24))) + u128::from(((__v_85.as_canonical_u64() << 0) | (__v_86.as_canonical_u64() << 8) | (__v_87.as_canonical_u64() << 16) | (__v_88.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_299: G = G::from_u8(__u32_bytes[0]);
+        let __v_300: G = G::from_u8(__u32_bytes[1]);
+        let __v_301: G = G::from_u8(__u32_bytes[2]);
+        let __v_302: G = G::from_u8(__u32_bytes[3]);
+        let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_299; let __vj = __v_300; 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_301; let __vj = __v_302; 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_304: G = G::from_u64(1);
+        let __v_305: G = (__v_303 - __v_304);
+        let __v_306: G = G::from_u64(2);
+        let __v_307: G = (__v_303 - __v_306);
+        let __v_308: G = (__v_305 * __v_307);
+        let __v_309: G = (__v_303 * __v_308);
+        let __v_310: G = G::from_u64(0);
+        if (__v_309 != __v_310) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) };
+        let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) };
+        let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) };
+        let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) };
+        let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_315: G = G::from_u8(__u32_bytes[0]);
+        let __v_316: G = G::from_u8(__u32_bytes[1]);
+        let __v_317: G = G::from_u8(__u32_bytes[2]);
+        let __v_318: G = G::from_u8(__u32_bytes[3]);
+        let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_315; let __vj = __v_316; 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_317; let __vj = __v_318; 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_320: G = (__v_319 * __v_319);
+        if (__v_320 != __v_319) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) };
+        let __v_321: G = __b2_out.0;
+        let __v_322: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) };
+        let __v_323: G = __b2_out.0;
+        let __v_324: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) };
+        let __v_325: G = __b2_out.0;
+        let __v_326: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) };
+        let __v_327: G = __b2_out.0;
+        let __v_328: G = __b2_out.1;
+        let __v_329: G = (__v_321 + __v_324);
+        let __v_330: G = (__v_323 + __v_326);
+        let __v_331: G = (__v_325 + __v_328);
+        let __v_332: G = (__v_327 + __v_322);
+        let __u32_sum: u128 = u128::from(((__v_13.as_canonical_u64() << 0) | (__v_14.as_canonical_u64() << 8) | (__v_15.as_canonical_u64() << 16) | (__v_16.as_canonical_u64() << 24))) + u128::from(((__v_29.as_canonical_u64() << 0) | (__v_30.as_canonical_u64() << 8) | (__v_31.as_canonical_u64() << 16) | (__v_32.as_canonical_u64() << 24))) + u128::from(((__v_89.as_canonical_u64() << 0) | (__v_90.as_canonical_u64() << 8) | (__v_91.as_canonical_u64() << 16) | (__v_92.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_333: G = G::from_u8(__u32_bytes[0]);
+        let __v_334: G = G::from_u8(__u32_bytes[1]);
+        let __v_335: G = G::from_u8(__u32_bytes[2]);
+        let __v_336: G = G::from_u8(__u32_bytes[3]);
+        let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_333; let __vj = __v_334; 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_335; let __vj = __v_336; 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_338: G = G::from_u64(1);
+        let __v_339: G = (__v_337 - __v_338);
+        let __v_340: G = G::from_u64(2);
+        let __v_341: G = (__v_337 - __v_340);
+        let __v_342: G = (__v_339 * __v_341);
+        let __v_343: G = (__v_337 * __v_342);
+        let __v_344: G = G::from_u64(0);
+        if (__v_343 != __v_344) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) };
+        let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) };
+        let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) };
+        let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) };
+        let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_349: G = G::from_u8(__u32_bytes[0]);
+        let __v_350: G = G::from_u8(__u32_bytes[1]);
+        let __v_351: G = G::from_u8(__u32_bytes[2]);
+        let __v_352: G = G::from_u8(__u32_bytes[3]);
+        let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_349; let __vj = __v_350; 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_351; let __vj = __v_352; 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_354: G = (__v_353 * __v_353);
+        if (__v_354 != __v_353) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) };
+        let __v_355: G = __b2_out.0;
+        let __v_356: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) };
+        let __v_357: G = __b2_out.0;
+        let __v_358: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) };
+        let __v_359: G = __b2_out.0;
+        let __v_360: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) };
+        let __v_361: G = __b2_out.0;
+        let __v_362: G = __b2_out.1;
+        let __v_363: G = (__v_357 + __v_360);
+        let __v_364: G = (__v_359 + __v_362);
+        let __v_365: G = (__v_361 + __v_356);
+        let __v_366: G = (__v_355 + __v_358);
+        let __u32_sum: u128 = u128::from(((__v_333.as_canonical_u64() << 0) | (__v_334.as_canonical_u64() << 8) | (__v_335.as_canonical_u64() << 16) | (__v_336.as_canonical_u64() << 24))) + u128::from(((__v_363.as_canonical_u64() << 0) | (__v_364.as_canonical_u64() << 8) | (__v_365.as_canonical_u64() << 16) | (__v_366.as_canonical_u64() << 24))) + u128::from(((__v_93.as_canonical_u64() << 0) | (__v_94.as_canonical_u64() << 8) | (__v_95.as_canonical_u64() << 16) | (__v_96.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_367: G = G::from_u8(__u32_bytes[0]);
+        let __v_368: G = G::from_u8(__u32_bytes[1]);
+        let __v_369: G = G::from_u8(__u32_bytes[2]);
+        let __v_370: G = G::from_u8(__u32_bytes[3]);
+        let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_367; let __vj = __v_368; 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_369; let __vj = __v_370; 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_372: G = G::from_u64(1);
+        let __v_373: G = (__v_371 - __v_372);
+        let __v_374: G = G::from_u64(2);
+        let __v_375: G = (__v_371 - __v_374);
+        let __v_376: G = (__v_373 * __v_375);
+        let __v_377: G = (__v_371 * __v_376);
+        let __v_378: G = G::from_u64(0);
+        if (__v_377 != __v_378) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) };
+        let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) };
+        let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) };
+        let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) };
+        let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_383: G = G::from_u8(__u32_bytes[0]);
+        let __v_384: G = G::from_u8(__u32_bytes[1]);
+        let __v_385: G = G::from_u8(__u32_bytes[2]);
+        let __v_386: G = G::from_u8(__u32_bytes[3]);
+        let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_383; let __vj = __v_384; 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_385; let __vj = __v_386; 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_388: G = (__v_387 * __v_387);
+        if (__v_388 != __v_387) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) };
+        let __v_389: G = __b2_out.0;
+        let __v_390: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) };
+        let __v_391: G = __b2_out.0;
+        let __v_392: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) };
+        let __v_393: G = __b2_out.0;
+        let __v_394: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) };
+        let __v_395: G = __b2_out.0;
+        let __v_396: G = __b2_out.1;
+        let __v_397: G = (__v_389 + __v_392);
+        let __v_398: G = (__v_391 + __v_394);
+        let __v_399: G = (__v_393 + __v_396);
+        let __v_400: G = (__v_395 + __v_390);
+        let __u32_sum: u128 = u128::from(((__v_163.as_canonical_u64() << 0) | (__v_164.as_canonical_u64() << 8) | (__v_165.as_canonical_u64() << 16) | (__v_166.as_canonical_u64() << 24))) + u128::from(((__v_261.as_canonical_u64() << 0) | (__v_262.as_canonical_u64() << 8) | (__v_263.as_canonical_u64() << 16) | (__v_264.as_canonical_u64() << 24))) + u128::from(((__v_97.as_canonical_u64() << 0) | (__v_98.as_canonical_u64() << 8) | (__v_99.as_canonical_u64() << 16) | (__v_100.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_401: G = G::from_u8(__u32_bytes[0]);
+        let __v_402: G = G::from_u8(__u32_bytes[1]);
+        let __v_403: G = G::from_u8(__u32_bytes[2]);
+        let __v_404: G = G::from_u8(__u32_bytes[3]);
+        let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_401; let __vj = __v_402; 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_403; let __vj = __v_404; 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_406: G = G::from_u64(1);
+        let __v_407: G = (__v_405 - __v_406);
+        let __v_408: G = G::from_u64(2);
+        let __v_409: G = (__v_405 - __v_408);
+        let __v_410: G = (__v_407 * __v_409);
+        let __v_411: G = (__v_405 * __v_410);
+        let __v_412: G = G::from_u64(0);
+        if (__v_411 != __v_412) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) };
+        let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) };
+        let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) };
+        let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) };
+        let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_417: G = G::from_u8(__u32_bytes[0]);
+        let __v_418: G = G::from_u8(__u32_bytes[1]);
+        let __v_419: G = G::from_u8(__u32_bytes[2]);
+        let __v_420: G = G::from_u8(__u32_bytes[3]);
+        let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_417; let __vj = __v_418; 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_419; let __vj = __v_420; 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_422: G = (__v_421 * __v_421);
+        if (__v_422 != __v_421) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) };
+        let __v_423: G = __b2_out.0;
+        let __v_424: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) };
+        let __v_425: G = __b2_out.0;
+        let __v_426: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) };
+        let __v_427: G = __b2_out.0;
+        let __v_428: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) };
+        let __v_429: G = __b2_out.0;
+        let __v_430: G = __b2_out.1;
+        let __v_431: G = (__v_425 + __v_428);
+        let __v_432: G = (__v_427 + __v_430);
+        let __v_433: G = (__v_429 + __v_424);
+        let __v_434: G = (__v_423 + __v_426);
+        let __u32_sum: u128 = u128::from(((__v_401.as_canonical_u64() << 0) | (__v_402.as_canonical_u64() << 8) | (__v_403.as_canonical_u64() << 16) | (__v_404.as_canonical_u64() << 24))) + u128::from(((__v_431.as_canonical_u64() << 0) | (__v_432.as_canonical_u64() << 8) | (__v_433.as_canonical_u64() << 16) | (__v_434.as_canonical_u64() << 24))) + u128::from(((__v_101.as_canonical_u64() << 0) | (__v_102.as_canonical_u64() << 8) | (__v_103.as_canonical_u64() << 16) | (__v_104.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_435: G = G::from_u8(__u32_bytes[0]);
+        let __v_436: G = G::from_u8(__u32_bytes[1]);
+        let __v_437: G = G::from_u8(__u32_bytes[2]);
+        let __v_438: G = G::from_u8(__u32_bytes[3]);
+        let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_435; let __vj = __v_436; 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_437; let __vj = __v_438; 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_440: G = G::from_u64(1);
+        let __v_441: G = (__v_439 - __v_440);
+        let __v_442: G = G::from_u64(2);
+        let __v_443: G = (__v_439 - __v_442);
+        let __v_444: G = (__v_441 * __v_443);
+        let __v_445: G = (__v_439 * __v_444);
+        let __v_446: G = G::from_u64(0);
+        if (__v_445 != __v_446) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) };
+        let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) };
+        let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) };
+        let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) };
+        let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_451: G = G::from_u8(__u32_bytes[0]);
+        let __v_452: G = G::from_u8(__u32_bytes[1]);
+        let __v_453: G = G::from_u8(__u32_bytes[2]);
+        let __v_454: G = G::from_u8(__u32_bytes[3]);
+        let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_451; let __vj = __v_452; 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_453; let __vj = __v_454; 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_456: G = (__v_455 * __v_455);
+        if (__v_456 != __v_455) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) };
+        let __v_457: G = __b2_out.0;
+        let __v_458: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) };
+        let __v_459: G = __b2_out.0;
+        let __v_460: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) };
+        let __v_461: G = __b2_out.0;
+        let __v_462: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) };
+        let __v_463: G = __b2_out.0;
+        let __v_464: G = __b2_out.1;
+        let __v_465: G = (__v_457 + __v_460);
+        let __v_466: G = (__v_459 + __v_462);
+        let __v_467: G = (__v_461 + __v_464);
+        let __v_468: G = (__v_463 + __v_458);
+        let __u32_sum: u128 = u128::from(((__v_231.as_canonical_u64() << 0) | (__v_232.as_canonical_u64() << 8) | (__v_233.as_canonical_u64() << 16) | (__v_234.as_canonical_u64() << 24))) + u128::from(((__v_329.as_canonical_u64() << 0) | (__v_330.as_canonical_u64() << 8) | (__v_331.as_canonical_u64() << 16) | (__v_332.as_canonical_u64() << 24))) + u128::from(((__v_105.as_canonical_u64() << 0) | (__v_106.as_canonical_u64() << 8) | (__v_107.as_canonical_u64() << 16) | (__v_108.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_469: G = G::from_u8(__u32_bytes[0]);
+        let __v_470: G = G::from_u8(__u32_bytes[1]);
+        let __v_471: G = G::from_u8(__u32_bytes[2]);
+        let __v_472: G = G::from_u8(__u32_bytes[3]);
+        let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_469; let __vj = __v_470; 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_471; let __vj = __v_472; 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_474: G = G::from_u64(1);
+        let __v_475: G = (__v_473 - __v_474);
+        let __v_476: G = G::from_u64(2);
+        let __v_477: G = (__v_473 - __v_476);
+        let __v_478: G = (__v_475 * __v_477);
+        let __v_479: G = (__v_473 * __v_478);
+        let __v_480: G = G::from_u64(0);
+        if (__v_479 != __v_480) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) };
+        let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) };
+        let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) };
+        let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) };
+        let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_485: G = G::from_u8(__u32_bytes[0]);
+        let __v_486: G = G::from_u8(__u32_bytes[1]);
+        let __v_487: G = G::from_u8(__u32_bytes[2]);
+        let __v_488: G = G::from_u8(__u32_bytes[3]);
+        let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_485; let __vj = __v_486; 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_487; let __vj = __v_488; 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_490: G = (__v_489 * __v_489);
+        if (__v_490 != __v_489) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) };
+        let __v_491: G = __b2_out.0;
+        let __v_492: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) };
+        let __v_493: G = __b2_out.0;
+        let __v_494: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) };
+        let __v_495: G = __b2_out.0;
+        let __v_496: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) };
+        let __v_497: G = __b2_out.0;
+        let __v_498: G = __b2_out.1;
+        let __v_499: G = (__v_493 + __v_496);
+        let __v_500: G = (__v_495 + __v_498);
+        let __v_501: G = (__v_497 + __v_492);
+        let __v_502: G = (__v_491 + __v_494);
+        let __u32_sum: u128 = u128::from(((__v_469.as_canonical_u64() << 0) | (__v_470.as_canonical_u64() << 8) | (__v_471.as_canonical_u64() << 16) | (__v_472.as_canonical_u64() << 24))) + u128::from(((__v_499.as_canonical_u64() << 0) | (__v_500.as_canonical_u64() << 8) | (__v_501.as_canonical_u64() << 16) | (__v_502.as_canonical_u64() << 24))) + u128::from(((__v_109.as_canonical_u64() << 0) | (__v_110.as_canonical_u64() << 8) | (__v_111.as_canonical_u64() << 16) | (__v_112.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_503: G = G::from_u8(__u32_bytes[0]);
+        let __v_504: G = G::from_u8(__u32_bytes[1]);
+        let __v_505: G = G::from_u8(__u32_bytes[2]);
+        let __v_506: G = G::from_u8(__u32_bytes[3]);
+        let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_503; let __vj = __v_504; 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_505; let __vj = __v_506; 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_508: G = G::from_u64(1);
+        let __v_509: G = (__v_507 - __v_508);
+        let __v_510: G = G::from_u64(2);
+        let __v_511: G = (__v_507 - __v_510);
+        let __v_512: G = (__v_509 * __v_511);
+        let __v_513: G = (__v_507 * __v_512);
+        let __v_514: G = G::from_u64(0);
+        if (__v_513 != __v_514) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) };
+        let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) };
+        let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) };
+        let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) };
+        let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_519: G = G::from_u8(__u32_bytes[0]);
+        let __v_520: G = G::from_u8(__u32_bytes[1]);
+        let __v_521: G = G::from_u8(__u32_bytes[2]);
+        let __v_522: G = G::from_u8(__u32_bytes[3]);
+        let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_519; let __vj = __v_520; 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_521; let __vj = __v_522; 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_524: G = (__v_523 * __v_523);
+        if (__v_524 != __v_523) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) };
+        let __v_525: G = __b2_out.0;
+        let __v_526: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) };
+        let __v_527: G = __b2_out.0;
+        let __v_528: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) };
+        let __v_529: G = __b2_out.0;
+        let __v_530: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) };
+        let __v_531: G = __b2_out.0;
+        let __v_532: G = __b2_out.1;
+        let __v_533: G = (__v_525 + __v_528);
+        let __v_534: G = (__v_527 + __v_530);
+        let __v_535: G = (__v_529 + __v_532);
+        let __v_536: G = (__v_531 + __v_526);
+        let __u32_sum: u128 = u128::from(((__v_299.as_canonical_u64() << 0) | (__v_300.as_canonical_u64() << 8) | (__v_301.as_canonical_u64() << 16) | (__v_302.as_canonical_u64() << 24))) + u128::from(((__v_397.as_canonical_u64() << 0) | (__v_398.as_canonical_u64() << 8) | (__v_399.as_canonical_u64() << 16) | (__v_400.as_canonical_u64() << 24))) + u128::from(((__v_113.as_canonical_u64() << 0) | (__v_114.as_canonical_u64() << 8) | (__v_115.as_canonical_u64() << 16) | (__v_116.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_537: G = G::from_u8(__u32_bytes[0]);
+        let __v_538: G = G::from_u8(__u32_bytes[1]);
+        let __v_539: G = G::from_u8(__u32_bytes[2]);
+        let __v_540: G = G::from_u8(__u32_bytes[3]);
+        let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_537; let __vj = __v_538; 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_539; let __vj = __v_540; 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_542: G = G::from_u64(1);
+        let __v_543: G = (__v_541 - __v_542);
+        let __v_544: G = G::from_u64(2);
+        let __v_545: G = (__v_541 - __v_544);
+        let __v_546: G = (__v_543 * __v_545);
+        let __v_547: G = (__v_541 * __v_546);
+        let __v_548: G = G::from_u64(0);
+        if (__v_547 != __v_548) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) };
+        let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) };
+        let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) };
+        let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) };
+        let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_553: G = G::from_u8(__u32_bytes[0]);
+        let __v_554: G = G::from_u8(__u32_bytes[1]);
+        let __v_555: G = G::from_u8(__u32_bytes[2]);
+        let __v_556: G = G::from_u8(__u32_bytes[3]);
+        let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_553; let __vj = __v_554; 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_555; let __vj = __v_556; 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_558: G = (__v_557 * __v_557);
+        if (__v_558 != __v_557) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) };
+        let __v_559: G = __b2_out.0;
+        let __v_560: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) };
+        let __v_561: G = __b2_out.0;
+        let __v_562: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) };
+        let __v_563: G = __b2_out.0;
+        let __v_564: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) };
+        let __v_565: G = __b2_out.0;
+        let __v_566: G = __b2_out.1;
+        let __v_567: G = (__v_561 + __v_564);
+        let __v_568: G = (__v_563 + __v_566);
+        let __v_569: G = (__v_565 + __v_560);
+        let __v_570: G = (__v_559 + __v_562);
+        let __u32_sum: u128 = u128::from(((__v_537.as_canonical_u64() << 0) | (__v_538.as_canonical_u64() << 8) | (__v_539.as_canonical_u64() << 16) | (__v_540.as_canonical_u64() << 24))) + u128::from(((__v_567.as_canonical_u64() << 0) | (__v_568.as_canonical_u64() << 8) | (__v_569.as_canonical_u64() << 16) | (__v_570.as_canonical_u64() << 24))) + u128::from(((__v_117.as_canonical_u64() << 0) | (__v_118.as_canonical_u64() << 8) | (__v_119.as_canonical_u64() << 16) | (__v_120.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_571: G = G::from_u8(__u32_bytes[0]);
+        let __v_572: G = G::from_u8(__u32_bytes[1]);
+        let __v_573: G = G::from_u8(__u32_bytes[2]);
+        let __v_574: G = G::from_u8(__u32_bytes[3]);
+        let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_571; let __vj = __v_572; 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_573; let __vj = __v_574; 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_576: G = G::from_u64(1);
+        let __v_577: G = (__v_575 - __v_576);
+        let __v_578: G = G::from_u64(2);
+        let __v_579: G = (__v_575 - __v_578);
+        let __v_580: G = (__v_577 * __v_579);
+        let __v_581: G = (__v_575 * __v_580);
+        let __v_582: G = G::from_u64(0);
+        if (__v_581 != __v_582) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) };
+        let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) };
+        let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) };
+        let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) };
+        let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_587: G = G::from_u8(__u32_bytes[0]);
+        let __v_588: G = G::from_u8(__u32_bytes[1]);
+        let __v_589: G = G::from_u8(__u32_bytes[2]);
+        let __v_590: G = G::from_u8(__u32_bytes[3]);
+        let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_587; let __vj = __v_588; 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_589; let __vj = __v_590; 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_592: G = (__v_591 * __v_591);
+        if (__v_592 != __v_591) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) };
+        let __v_593: G = __b2_out.0;
+        let __v_594: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) };
+        let __v_595: G = __b2_out.0;
+        let __v_596: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) };
+        let __v_597: G = __b2_out.0;
+        let __v_598: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) };
+        let __v_599: G = __b2_out.0;
+        let __v_600: G = __b2_out.1;
+        let __v_601: G = (__v_593 + __v_596);
+        let __v_602: G = (__v_595 + __v_598);
+        let __v_603: G = (__v_597 + __v_600);
+        let __v_604: G = (__v_599 + __v_594);
+        let __u32_sum: u128 = u128::from(((__v_367.as_canonical_u64() << 0) | (__v_368.as_canonical_u64() << 8) | (__v_369.as_canonical_u64() << 16) | (__v_370.as_canonical_u64() << 24))) + u128::from(((__v_193.as_canonical_u64() << 0) | (__v_194.as_canonical_u64() << 8) | (__v_195.as_canonical_u64() << 16) | (__v_196.as_canonical_u64() << 24))) + u128::from(((__v_121.as_canonical_u64() << 0) | (__v_122.as_canonical_u64() << 8) | (__v_123.as_canonical_u64() << 16) | (__v_124.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_605: G = G::from_u8(__u32_bytes[0]);
+        let __v_606: G = G::from_u8(__u32_bytes[1]);
+        let __v_607: G = G::from_u8(__u32_bytes[2]);
+        let __v_608: G = G::from_u8(__u32_bytes[3]);
+        let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_605; let __vj = __v_606; 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_607; let __vj = __v_608; 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_610: G = G::from_u64(1);
+        let __v_611: G = (__v_609 - __v_610);
+        let __v_612: G = G::from_u64(2);
+        let __v_613: G = (__v_609 - __v_612);
+        let __v_614: G = (__v_611 * __v_613);
+        let __v_615: G = (__v_609 * __v_614);
+        let __v_616: G = G::from_u64(0);
+        if (__v_615 != __v_616) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) };
+        let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) };
+        let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) };
+        let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) };
+        let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_621: G = G::from_u8(__u32_bytes[0]);
+        let __v_622: G = G::from_u8(__u32_bytes[1]);
+        let __v_623: G = G::from_u8(__u32_bytes[2]);
+        let __v_624: G = G::from_u8(__u32_bytes[3]);
+        let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_621; let __vj = __v_622; 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_623; let __vj = __v_624; 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_626: G = (__v_625 * __v_625);
+        if (__v_626 != __v_625) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) };
+        let __v_627: G = __b2_out.0;
+        let __v_628: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) };
+        let __v_629: G = __b2_out.0;
+        let __v_630: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) };
+        let __v_631: G = __b2_out.0;
+        let __v_632: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) };
+        let __v_633: G = __b2_out.0;
+        let __v_634: G = __b2_out.1;
+        let __v_635: G = (__v_629 + __v_632);
+        let __v_636: G = (__v_631 + __v_634);
+        let __v_637: G = (__v_633 + __v_628);
+        let __v_638: G = (__v_627 + __v_630);
+        let __u32_sum: u128 = u128::from(((__v_605.as_canonical_u64() << 0) | (__v_606.as_canonical_u64() << 8) | (__v_607.as_canonical_u64() << 16) | (__v_608.as_canonical_u64() << 24))) + u128::from(((__v_635.as_canonical_u64() << 0) | (__v_636.as_canonical_u64() << 8) | (__v_637.as_canonical_u64() << 16) | (__v_638.as_canonical_u64() << 24))) + u128::from(((__v_125.as_canonical_u64() << 0) | (__v_126.as_canonical_u64() << 8) | (__v_127.as_canonical_u64() << 16) | (__v_128.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_639: G = G::from_u8(__u32_bytes[0]);
+        let __v_640: G = G::from_u8(__u32_bytes[1]);
+        let __v_641: G = G::from_u8(__u32_bytes[2]);
+        let __v_642: G = G::from_u8(__u32_bytes[3]);
+        let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_639; let __vj = __v_640; 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_641; let __vj = __v_642; 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_644: G = G::from_u64(1);
+        let __v_645: G = (__v_643 - __v_644);
+        let __v_646: G = G::from_u64(2);
+        let __v_647: G = (__v_643 - __v_646);
+        let __v_648: G = (__v_645 * __v_647);
+        let __v_649: G = (__v_643 * __v_648);
+        let __v_650: G = G::from_u64(0);
+        if (__v_649 != __v_650) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
+        }
+        let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) };
+        let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) };
+        let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) };
+        let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) };
+        let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24)));
+        let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes();
+        let __v_655: G = G::from_u8(__u32_bytes[0]);
+        let __v_656: G = G::from_u8(__u32_bytes[1]);
+        let __v_657: G = G::from_u8(__u32_bytes[2]);
+        let __v_658: G = G::from_u8(__u32_bytes[3]);
+        let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64"));
+        if !unconstrained { let __vi = __v_655; let __vj = __v_656; 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_657; let __vj = __v_658; 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_660: G = (__v_659 * __v_659);
+        if (__v_660 != __v_659) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
+        }
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) };
+        let __v_661: G = __b2_out.0;
+        let __v_662: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) };
+        let __v_663: G = __b2_out.0;
+        let __v_664: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) };
+        let __v_665: G = __b2_out.0;
+        let __v_666: G = __b2_out.1;
+        let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) };
+        let __v_667: G = __b2_out.0;
+        let __v_668: G = __b2_out.1;
+        let __v_669: G = (__v_661 + __v_664);
+        let __v_670: G = (__v_663 + __v_666);
+        let __v_671: G = (__v_665 + __v_668);
+        let __v_672: G = (__v_667 + __v_662);
+        let __v_673: G = G::from_u64(1);
+        let __v_674: G = (__v_0 + __v_673);
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_675: G = __r_arr[0];
+        let __v_676: G = __r_arr[1];
+        let __v_677: G = __r_arr[2];
+        let __v_678: G = __r_arr[3];
+        let __v_679: G = __r_arr[4];
+        let __v_680: G = __r_arr[5];
+        let __v_681: G = __r_arr[6];
+        let __v_682: G = __r_arr[7];
+        let __v_683: G = __r_arr[8];
+        let __v_684: G = __r_arr[9];
+        let __v_685: G = __r_arr[10];
+        let __v_686: G = __r_arr[11];
+        let __v_687: G = __r_arr[12];
+        let __v_688: G = __r_arr[13];
+        let __v_689: G = __r_arr[14];
+        let __v_690: G = __r_arr[15];
+        let __v_691: G = __r_arr[16];
+        let __v_692: G = __r_arr[17];
+        let __v_693: G = __r_arr[18];
+        let __v_694: G = __r_arr[19];
+        let __v_695: G = __r_arr[20];
+        let __v_696: G = __r_arr[21];
+        let __v_697: G = __r_arr[22];
+        let __v_698: G = __r_arr[23];
+        let __v_699: G = __r_arr[24];
+        let __v_700: G = __r_arr[25];
+        let __v_701: G = __r_arr[26];
+        let __v_702: G = __r_arr[27];
+        let __v_703: G = __r_arr[28];
+        let __v_704: G = __r_arr[29];
+        let __v_705: G = __r_arr[30];
+        let __v_706: G = __r_arr[31];
+        let __ret: [G; OUT_76] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
+        if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+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_77], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __ret: [G; OUT_77] = [__v_2, __v_3];
+        if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_78: usize = 1;
+const IN_78: usize = 1;
+const OUT_78: usize = 2;
+fn aiur_fn_78(
+  inp: [G; IN_78],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_78], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_78] = [__v_1, __v_2];
+    if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_79: usize = 1;
+const IN_79: usize = 1;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_79], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(256);
+    let __v_6: G = (__v_5 * __v_3);
+    let __v_7: G = (__v_1 + __v_6);
+    let __ret: [G; OUT_79] = [__v_7, __v_4];
+    if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+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_80], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(256);
+    let __v_6: G = (__v_5 * __v_3);
+    let __v_7: G = (__v_1 + __v_6);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __ret: [G; OUT_80] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4];
+    if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+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_81], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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(256);
+    let __v_10: G = (__v_9 * __v_3);
+    let __v_11: G = G::from_u64(65536);
+    let __v_12: G = (__v_11 * __v_5);
+    let __v_13: G = G::from_u64(16777216);
+    let __v_14: G = (__v_13 * __v_7);
+    let __v_15: G = (__v_12 + __v_14);
+    let __v_16: G = (__v_10 + __v_15);
+    let __v_17: G = (__v_1 + __v_16);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(0);
+    let __ret: [G; OUT_81] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8];
+    if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_82: usize = 1;
+const IN_82: usize = 1;
+const OUT_82: usize = 9;
+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 __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __v_10: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = __r_arr[1];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __ret: [G; OUT_82] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_83: usize = 1;
+const IN_83: usize = 1;
+const OUT_83: usize = 2;
+fn aiur_fn_83(
+  inp: [G; IN_83],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_83], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_10 * __v_2);
+    let __v_12: G = G::from_u64(65536);
+    let __v_13: G = (__v_12 * __v_3);
+    let __v_14: G = G::from_u64(16777216);
+    let __v_15: G = (__v_14 * __v_4);
+    let __v_16: G = G::from_u64(4294967296);
+    let __v_17: G = (__v_16 * __v_5);
+    let __v_18: G = G::from_u64(1099511627776);
+    let __v_19: G = (__v_18 * __v_6);
+    let __v_20: G = G::from_u64(281474976710656);
+    let __v_21: G = (__v_20 * __v_7);
+    let __v_22: G = G::from_u64(72057594037927936);
+    let __v_23: G = (__v_22 * __v_8);
+    let __v_24: G = (__v_21 + __v_23);
+    let __v_25: G = (__v_19 + __v_24);
+    let __v_26: G = (__v_17 + __v_25);
+    let __v_27: G = (__v_15 + __v_26);
+    let __v_28: G = (__v_13 + __v_27);
+    let __v_29: G = (__v_11 + __v_28);
+    let __v_30: G = (__v_1 + __v_29);
+    let __ret: [G; OUT_83] = [__v_30, __v_9];
+    if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_84: usize = 1;
+const IN_84: usize = 1;
+const OUT_84: usize = 33;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __v_12: G = __r_arr[2];
+    let __v_13: G = __r_arr[3];
+    let __v_14: G = __r_arr[4];
+    let __v_15: G = __r_arr[5];
+    let __v_16: G = __r_arr[6];
+    let __v_17: G = __r_arr[7];
+    let __v_18: G = __r_arr[8];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+    let __v_20: G = __r_arr[1];
+    let __v_21: G = __r_arr[2];
+    let __v_22: G = __r_arr[3];
+    let __v_23: G = __r_arr[4];
+    let __v_24: G = __r_arr[5];
+    let __v_25: G = __r_arr[6];
+    let __v_26: G = __r_arr[7];
+    let __v_27: G = __r_arr[8];
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __ret: [G; OUT_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_85: usize = 2;
+const IN_85: usize = 2;
+const OUT_85: usize = 2;
+fn aiur_fn_85(
+  inp: [G; IN_85],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_85], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_85] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_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_82] = { let __args: [G; IN_82] = [__v_19]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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 = __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_82] = { let __args: [G; IN_82] = [__v_28]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __v_32: G = __r_arr[3];
+        let __v_33: G = __r_arr[4];
+        let __v_34: G = __r_arr[5];
+        let __v_35: G = __r_arr[6];
+        let __v_36: G = __r_arr[7];
+        let __v_37: G = __r_arr[8];
+        let __v_38: G = G::from_u64(1);
+        let __v_39: G = (__v_1 - __v_38);
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_85] = [__v_44, __v_41];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_86: usize = 2;
+const IN_86: usize = 2;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_86], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_86] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; 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 { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+            let __v_5: G = __r_arr[1];
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(2);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(3);
+            let __v_10: G = G::from_u64(3);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(4);
+            let __v_10: G = G::from_u64(4);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          5u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_1 - __v_4);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(5);
+            let __v_10: G = G::from_u64(5);
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          6u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(6);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          7u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(7);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          8u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = (__v_1 - __v_8);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(8);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          9u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(9);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          10u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(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; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          11u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          12u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          13u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          14u64 => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(2);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = __r_arr[1];
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = G::from_u64(2);
+            let __v_13: G = G::from_u64(1);
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_87: usize = 2;
+const IN_87: usize = 2;
+const OUT_87: usize = 2;
+fn aiur_fn_87(
+  inp: [G; IN_87],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_87], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 3;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_2]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __v_11: G = __r_arr[8];
+    let __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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_13, __v_12]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __ret: [G; OUT_88] = [__v_1, __v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_89: usize = 2;
+const IN_89: usize = 2;
+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_89], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_3]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = __r_arr[2];
+        let __v_7: G = __r_arr[3];
+        let __v_8: G = __r_arr[4];
+        let __v_9: G = __r_arr[5];
+        let __v_10: G = __r_arr[6];
+        let __v_11: G = __r_arr[7];
+        let __v_12: G = __r_arr[8];
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_12]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14, __v_13]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = (__v_1 - __v_17);
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_16, __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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = { let __values: [G; 4] = [__v_21, __v_2, __v_15, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_22, __v_20];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_90: usize = 3;
+const IN_90: usize = 3;
+const OUT_90: usize = 1;
+fn aiur_fn_90(
+  inp: [G; IN_90],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_90], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 __v_3: G = G::from_u64(0);
+        let __ret: [G; OUT_90] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        match __v_1.as_canonical_u64() {
+          0u64 => {
+            let __v_3: G = G::from_u64(1);
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = (__v_0 - __v_4);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_2 - __v_6);
+            let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = (__v_3 + __v_8);
+            let __ret: [G; OUT_90] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_3: G = G::from_u64(1);
+            let __v_4: G = (__v_0 - __v_3);
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = (__v_1 - __v_5);
+            let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __ret: [G; OUT_90] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_91: usize = 1;
+const IN_91: usize = 1;
+const OUT_91: usize = 63;
+fn aiur_fn_91(
+  inp: [G; IN_91],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_91], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
+    let __v_44: G = __r_arr[1];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+    let __v_46: G = __r_arr[1];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; 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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
+    let __v_54: G = __r_arr[1];
+    let __v_55: G = G::from_u64(0);
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
+    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+    let __v_58: G = (__v_56 + __v_57);
+    let __v_59: G = (__v_58 + __v_58);
+    let __v_60: G = (__v_47 + __v_59);
+    let __gb: [u8; 8] = __v_60.as_canonical_u64().to_le_bytes();
+    let __v_61: G = G::from_u8(__gb[0]);
+    let __v_62: G = G::from_u8(__gb[1]);
+    let __v_63: G = G::from_u8(__gb[2]);
+    let __v_64: G = G::from_u8(__gb[3]);
+    let __v_65: G = G::from_u8(__gb[4]);
+    let __v_66: G = G::from_u8(__gb[5]);
+    let __v_67: G = G::from_u8(__gb[6]);
+    let __v_68: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_61; let __vj = __v_62; 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_63; let __vj = __v_64; 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_65; let __vj = __v_66; 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_67; let __vj = __v_68; 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_69: G = G::from_u64(1020);
+    let __v_70: G = (__v_68 - __v_69);
+    let __v_71: G = (__v_67 + __v_70);
+    let __v_72: G = (__v_66 + __v_71);
+    let __v_73: G = (__v_65 + __v_72);
+    let __v_74: G = G::from_bool((__v_73 == G::ZERO));
+    let __v_75: G = (__v_63 + __v_64);
+    let __v_76: G = (__v_62 + __v_75);
+    let __v_77: G = (__v_61 + __v_76);
+    let __v_78: G = G::from_bool((__v_77 == G::ZERO));
+    let __v_79: G = G::from_u64(256);
+    let __v_80: G = (__v_79 * __v_62);
+    let __v_81: G = G::from_u64(65536);
+    let __v_82: G = (__v_81 * __v_63);
+    let __v_83: G = G::from_u64(16777216);
+    let __v_84: G = (__v_83 * __v_64);
+    let __v_85: G = G::from_u64(4294967296);
+    let __v_86: G = (__v_85 * __v_65);
+    let __v_87: G = G::from_u64(1099511627776);
+    let __v_88: G = (__v_87 * __v_66);
+    let __v_89: G = G::from_u64(281474976710656);
+    let __v_90: G = (__v_89 * __v_67);
+    let __v_91: G = G::from_u64(72057594037927936);
+    let __v_92: G = (__v_91 * __v_68);
+    let __v_93: G = (__v_90 + __v_92);
+    let __v_94: G = (__v_88 + __v_93);
+    let __v_95: G = (__v_86 + __v_94);
+    let __v_96: G = (__v_84 + __v_95);
+    let __v_97: G = (__v_82 + __v_96);
+    let __v_98: G = (__v_80 + __v_97);
+    let __v_99: G = (__v_61 + __v_98);
+    if (__v_99 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_99.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    }
+    let __v_100: G = G::from_u64(1);
+    let __v_101: G = G::from_u64(1);
+    let __v_102: G = (__v_101 - __v_78);
+    let __v_103: G = (__v_74 * __v_102);
+    let __v_104: G = (__v_100 - __v_103);
+    let __v_105: G = G::from_u64(1);
+    if (__v_104 != __v_105) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
+    }
+    let __v_106: G = (__v_58 + __v_58);
+    let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes();
+    let __v_107: G = G::from_u8(__gb[0]);
+    let __v_108: G = G::from_u8(__gb[1]);
+    let __v_109: G = G::from_u8(__gb[2]);
+    let __v_110: G = G::from_u8(__gb[3]);
+    let __v_111: G = G::from_u8(__gb[4]);
+    let __v_112: G = G::from_u8(__gb[5]);
+    let __v_113: G = G::from_u8(__gb[6]);
+    let __v_114: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_107; let __vj = __v_108; 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_109; let __vj = __v_110; 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_111; let __vj = __v_112; 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_113; let __vj = __v_114; 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_115: G = G::from_u64(1020);
+    let __v_116: G = (__v_114 - __v_115);
+    let __v_117: G = (__v_113 + __v_116);
+    let __v_118: G = (__v_112 + __v_117);
+    let __v_119: G = (__v_111 + __v_118);
+    let __v_120: G = G::from_bool((__v_119 == G::ZERO));
+    let __v_121: G = (__v_109 + __v_110);
+    let __v_122: G = (__v_108 + __v_121);
+    let __v_123: G = (__v_107 + __v_122);
+    let __v_124: G = G::from_bool((__v_123 == G::ZERO));
+    let __v_125: G = G::from_u64(256);
+    let __v_126: G = (__v_125 * __v_108);
+    let __v_127: G = G::from_u64(65536);
+    let __v_128: G = (__v_127 * __v_109);
+    let __v_129: G = G::from_u64(16777216);
+    let __v_130: G = (__v_129 * __v_110);
+    let __v_131: G = G::from_u64(4294967296);
+    let __v_132: G = (__v_131 * __v_111);
+    let __v_133: G = G::from_u64(1099511627776);
+    let __v_134: G = (__v_133 * __v_112);
+    let __v_135: G = G::from_u64(281474976710656);
+    let __v_136: G = (__v_135 * __v_113);
+    let __v_137: G = G::from_u64(72057594037927936);
+    let __v_138: G = (__v_137 * __v_114);
+    let __v_139: G = (__v_136 + __v_138);
+    let __v_140: G = (__v_134 + __v_139);
+    let __v_141: G = (__v_132 + __v_140);
+    let __v_142: G = (__v_130 + __v_141);
+    let __v_143: G = (__v_128 + __v_142);
+    let __v_144: G = (__v_126 + __v_143);
+    let __v_145: G = (__v_107 + __v_144);
+    if (__v_145 != __v_106) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+    }
+    let __v_146: G = G::from_u64(1);
+    let __v_147: G = G::from_u64(1);
+    let __v_148: G = (__v_147 - __v_124);
+    let __v_149: G = (__v_120 * __v_148);
+    let __v_150: G = (__v_146 - __v_149);
+    let __v_151: G = G::from_u64(1);
+    if (__v_150 != __v_151) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None });
+    }
+    let __gb: [u8; 8] = __v_41.as_canonical_u64().to_le_bytes();
+    let __v_152: G = G::from_u8(__gb[0]);
+    let __v_153: G = G::from_u8(__gb[1]);
+    let __v_154: G = G::from_u8(__gb[2]);
+    let __v_155: G = G::from_u8(__gb[3]);
+    let __v_156: G = G::from_u8(__gb[4]);
+    let __v_157: G = G::from_u8(__gb[5]);
+    let __v_158: G = G::from_u8(__gb[6]);
+    let __v_159: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_152; let __vj = __v_153; 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_154; let __vj = __v_155; 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_156; let __vj = __v_157; 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_158; let __vj = __v_159; 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_160: G = G::from_u64(1020);
+    let __v_161: G = (__v_159 - __v_160);
+    let __v_162: G = (__v_158 + __v_161);
+    let __v_163: G = (__v_157 + __v_162);
+    let __v_164: G = (__v_156 + __v_163);
+    let __v_165: G = G::from_bool((__v_164 == G::ZERO));
+    let __v_166: G = (__v_154 + __v_155);
+    let __v_167: G = (__v_153 + __v_166);
+    let __v_168: G = (__v_152 + __v_167);
+    let __v_169: G = G::from_bool((__v_168 == G::ZERO));
+    let __v_170: G = G::from_u64(256);
+    let __v_171: G = (__v_170 * __v_153);
+    let __v_172: G = G::from_u64(65536);
+    let __v_173: G = (__v_172 * __v_154);
+    let __v_174: G = G::from_u64(16777216);
+    let __v_175: G = (__v_174 * __v_155);
+    let __v_176: G = G::from_u64(4294967296);
+    let __v_177: G = (__v_176 * __v_156);
+    let __v_178: G = G::from_u64(1099511627776);
+    let __v_179: G = (__v_178 * __v_157);
+    let __v_180: G = G::from_u64(281474976710656);
+    let __v_181: G = (__v_180 * __v_158);
+    let __v_182: G = G::from_u64(72057594037927936);
+    let __v_183: G = (__v_182 * __v_159);
+    let __v_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_179 + __v_184);
+    let __v_186: G = (__v_177 + __v_185);
+    let __v_187: G = (__v_175 + __v_186);
+    let __v_188: G = (__v_173 + __v_187);
+    let __v_189: G = (__v_171 + __v_188);
+    let __v_190: G = (__v_152 + __v_189);
+    if (__v_190 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: None });
+    }
+    let __v_191: G = G::from_u64(1);
+    let __v_192: G = G::from_u64(1);
+    let __v_193: G = (__v_192 - __v_169);
+    let __v_194: G = (__v_165 * __v_193);
+    let __v_195: G = (__v_191 - __v_194);
+    let __v_196: G = G::from_u64(1);
+    if (__v_195 != __v_196) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_91] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54];
+    if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_92: usize = 57;
+const IN_92: usize = 57;
+const OUT_92: usize = 1;
+fn aiur_fn_92(
+  inp: [G; IN_92],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_92], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __v_44: G = inp[44];
+    let __v_45: G = inp[45];
+    let __v_46: G = inp[46];
+    let __v_47: G = inp[47];
+    let __v_48: G = inp[48];
+    let __v_49: G = inp[49];
+    let __v_50: G = inp[50];
+    let __v_51: G = inp[51];
+    let __v_52: G = inp[52];
+    let __v_53: G = inp[53];
+    let __v_54: G = inp[54];
+    let __v_55: G = inp[55];
+    let __v_56: G = inp[56];
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_92] = [__v_70];
+    if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_93: usize = 2;
+const IN_93: usize = 2;
+const OUT_93: usize = 3;
+fn aiur_fn_93(
+  inp: [G; IN_93],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_93], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_93] = [__v_4, __v_7, __v_0];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = __r_arr[9];
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __v_13: G = __r_arr[1];
+        let __v_14: G = __r_arr[2];
+        let __v_15: G = __r_arr[3];
+        let __v_16: G = __r_arr[4];
+        let __v_17: G = __r_arr[5];
+        let __v_18: G = __r_arr[6];
+        let __v_19: G = __r_arr[7];
+        let __v_20: G = __r_arr[8];
+        let __v_21: G = __r_arr[9];
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = __r_arr[2];
+        let __v_25: G = __r_arr[3];
+        let __v_26: G = __r_arr[4];
+        let __v_27: G = __r_arr[5];
+        let __v_28: G = __r_arr[6];
+        let __v_29: G = __r_arr[7];
+        let __v_30: G = __r_arr[8];
+        let __v_31: G = __r_arr[9];
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_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 __v_41: G = __r_arr[9];
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+        let __v_43: G = __r_arr[1];
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __v_47: G = __r_arr[1];
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+        let __v_49: G = __r_arr[1];
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
+        let __v_51: G = __r_arr[1];
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+        let __v_53: G = __r_arr[1];
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; 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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
+        let __v_55: G = __r_arr[1];
+        let __v_56: G = G::from_u64(0);
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
+        let __v_58: G = G::from_bool((__v_57 == G::ZERO));
+        let __v_59: G = (__v_57 + __v_58);
+        let __v_60: G = (__v_59 + __v_59);
+        let __v_61: G = (__v_48 + __v_60);
+        let __gb: [u8; 8] = __v_61.as_canonical_u64().to_le_bytes();
+        let __v_62: G = G::from_u8(__gb[0]);
+        let __v_63: G = G::from_u8(__gb[1]);
+        let __v_64: G = G::from_u8(__gb[2]);
+        let __v_65: G = G::from_u8(__gb[3]);
+        let __v_66: G = G::from_u8(__gb[4]);
+        let __v_67: G = G::from_u8(__gb[5]);
+        let __v_68: G = G::from_u8(__gb[6]);
+        let __v_69: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66; let __vj = __v_67; 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_68; let __vj = __v_69; 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_70: G = G::from_u64(1020);
+        let __v_71: G = (__v_69 - __v_70);
+        let __v_72: G = (__v_68 + __v_71);
+        let __v_73: G = (__v_67 + __v_72);
+        let __v_74: G = (__v_66 + __v_73);
+        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+        let __v_76: G = (__v_64 + __v_65);
+        let __v_77: G = (__v_63 + __v_76);
+        let __v_78: G = (__v_62 + __v_77);
+        let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+        let __v_80: G = G::from_u64(256);
+        let __v_81: G = (__v_80 * __v_63);
+        let __v_82: G = G::from_u64(65536);
+        let __v_83: G = (__v_82 * __v_64);
+        let __v_84: G = G::from_u64(16777216);
+        let __v_85: G = (__v_84 * __v_65);
+        let __v_86: G = G::from_u64(4294967296);
+        let __v_87: G = (__v_86 * __v_66);
+        let __v_88: G = G::from_u64(1099511627776);
+        let __v_89: G = (__v_88 * __v_67);
+        let __v_90: G = G::from_u64(281474976710656);
+        let __v_91: G = (__v_90 * __v_68);
+        let __v_92: G = G::from_u64(72057594037927936);
+        let __v_93: G = (__v_92 * __v_69);
+        let __v_94: G = (__v_91 + __v_93);
+        let __v_95: G = (__v_89 + __v_94);
+        let __v_96: G = (__v_87 + __v_95);
+        let __v_97: G = (__v_85 + __v_96);
+        let __v_98: G = (__v_83 + __v_97);
+        let __v_99: G = (__v_81 + __v_98);
+        let __v_100: G = (__v_62 + __v_99);
+        if (__v_100 != __v_61) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_100.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+        }
+        let __v_101: G = G::from_u64(1);
+        let __v_102: G = G::from_u64(1);
+        let __v_103: G = (__v_102 - __v_79);
+        let __v_104: G = (__v_75 * __v_103);
+        let __v_105: G = (__v_101 - __v_104);
+        let __v_106: G = G::from_u64(1);
+        if (__v_105 != __v_106) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_105.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+        }
+        let __v_107: G = (__v_59 + __v_59);
+        let __gb: [u8; 8] = __v_107.as_canonical_u64().to_le_bytes();
+        let __v_108: G = G::from_u8(__gb[0]);
+        let __v_109: G = G::from_u8(__gb[1]);
+        let __v_110: G = G::from_u8(__gb[2]);
+        let __v_111: G = G::from_u8(__gb[3]);
+        let __v_112: G = G::from_u8(__gb[4]);
+        let __v_113: G = G::from_u8(__gb[5]);
+        let __v_114: G = G::from_u8(__gb[6]);
+        let __v_115: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_108; let __vj = __v_109; 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_110; let __vj = __v_111; 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_112; let __vj = __v_113; 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_114; let __vj = __v_115; 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_116: G = G::from_u64(1020);
+        let __v_117: G = (__v_115 - __v_116);
+        let __v_118: G = (__v_114 + __v_117);
+        let __v_119: G = (__v_113 + __v_118);
+        let __v_120: G = (__v_112 + __v_119);
+        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
+        let __v_122: G = (__v_110 + __v_111);
+        let __v_123: G = (__v_109 + __v_122);
+        let __v_124: G = (__v_108 + __v_123);
+        let __v_125: G = G::from_bool((__v_124 == G::ZERO));
+        let __v_126: G = G::from_u64(256);
+        let __v_127: G = (__v_126 * __v_109);
+        let __v_128: G = G::from_u64(65536);
+        let __v_129: G = (__v_128 * __v_110);
+        let __v_130: G = G::from_u64(16777216);
+        let __v_131: G = (__v_130 * __v_111);
+        let __v_132: G = G::from_u64(4294967296);
+        let __v_133: G = (__v_132 * __v_112);
+        let __v_134: G = G::from_u64(1099511627776);
+        let __v_135: G = (__v_134 * __v_113);
+        let __v_136: G = G::from_u64(281474976710656);
+        let __v_137: G = (__v_136 * __v_114);
+        let __v_138: G = G::from_u64(72057594037927936);
+        let __v_139: G = (__v_138 * __v_115);
+        let __v_140: G = (__v_137 + __v_139);
+        let __v_141: G = (__v_135 + __v_140);
+        let __v_142: G = (__v_133 + __v_141);
+        let __v_143: G = (__v_131 + __v_142);
+        let __v_144: G = (__v_129 + __v_143);
+        let __v_145: G = (__v_127 + __v_144);
+        let __v_146: G = (__v_108 + __v_145);
+        if (__v_146 != __v_107) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_107.as_canonical_u64(), msg: None });
+        }
+        let __v_147: G = G::from_u64(1);
+        let __v_148: G = G::from_u64(1);
+        let __v_149: G = (__v_148 - __v_125);
+        let __v_150: G = (__v_121 * __v_149);
+        let __v_151: G = (__v_147 - __v_150);
+        let __v_152: G = G::from_u64(1);
+        if (__v_151 != __v_152) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_151.as_canonical_u64(), rhs: __v_152.as_canonical_u64(), msg: None });
+        }
+        let __gb: [u8; 8] = __v_42.as_canonical_u64().to_le_bytes();
+        let __v_153: G = G::from_u8(__gb[0]);
+        let __v_154: G = G::from_u8(__gb[1]);
+        let __v_155: G = G::from_u8(__gb[2]);
+        let __v_156: G = G::from_u8(__gb[3]);
+        let __v_157: G = G::from_u8(__gb[4]);
+        let __v_158: G = G::from_u8(__gb[5]);
+        let __v_159: G = G::from_u8(__gb[6]);
+        let __v_160: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_153; let __vj = __v_154; 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_155; let __vj = __v_156; 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_157; let __vj = __v_158; 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_159; let __vj = __v_160; 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_161: G = G::from_u64(1020);
+        let __v_162: G = (__v_160 - __v_161);
+        let __v_163: G = (__v_159 + __v_162);
+        let __v_164: G = (__v_158 + __v_163);
+        let __v_165: G = (__v_157 + __v_164);
+        let __v_166: G = G::from_bool((__v_165 == G::ZERO));
+        let __v_167: G = (__v_155 + __v_156);
+        let __v_168: G = (__v_154 + __v_167);
+        let __v_169: G = (__v_153 + __v_168);
+        let __v_170: G = G::from_bool((__v_169 == G::ZERO));
+        let __v_171: G = G::from_u64(256);
+        let __v_172: G = (__v_171 * __v_154);
+        let __v_173: G = G::from_u64(65536);
+        let __v_174: G = (__v_173 * __v_155);
+        let __v_175: G = G::from_u64(16777216);
+        let __v_176: G = (__v_175 * __v_156);
+        let __v_177: G = G::from_u64(4294967296);
+        let __v_178: G = (__v_177 * __v_157);
+        let __v_179: G = G::from_u64(1099511627776);
+        let __v_180: G = (__v_179 * __v_158);
+        let __v_181: G = G::from_u64(281474976710656);
+        let __v_182: G = (__v_181 * __v_159);
+        let __v_183: G = G::from_u64(72057594037927936);
+        let __v_184: G = (__v_183 * __v_160);
+        let __v_185: G = (__v_182 + __v_184);
+        let __v_186: G = (__v_180 + __v_185);
+        let __v_187: G = (__v_178 + __v_186);
+        let __v_188: G = (__v_176 + __v_187);
+        let __v_189: G = (__v_174 + __v_188);
+        let __v_190: G = (__v_172 + __v_189);
+        let __v_191: G = (__v_153 + __v_190);
+        if (__v_191 != __v_42) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_191.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: None });
+        }
+        let __v_192: G = G::from_u64(1);
+        let __v_193: G = G::from_u64(1);
+        let __v_194: G = (__v_193 - __v_170);
+        let __v_195: G = (__v_166 * __v_194);
+        let __v_196: G = (__v_192 - __v_195);
+        let __v_197: G = G::from_u64(1);
+        if (__v_196 != __v_197) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_196.as_canonical_u64(), rhs: __v_197.as_canonical_u64(), msg: None });
+        }
+        let __v_198: G = G::from_u64(1);
+        let __v_199: G = (__v_1 - __v_198);
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_200: G = __r_arr[0];
+        let __v_201: G = __r_arr[1];
+        let __v_202: G = __r_arr[2];
+        let __v_203: G = G::from_u64(0);
+        let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_205: G = G::from_u64(0);
+        let __v_206: G = G::from_u64(0);
+        let __v_207: G = G::from_u64(0);
+        let __v_208: G = G::from_u64(0);
+        let __v_209: G = G::from_u64(0);
+        let __v_210: G = G::from_u64(0);
+        let __v_211: G = G::from_u64(0);
+        let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_93] = [__v_204, __v_218, __v_202];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 3;
+fn aiur_fn_94(
+  inp: [G; IN_94],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_94], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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(0);
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_94] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __v_7: G = G::from_u64(1);
+        let __ret: [G; OUT_94] = [__v_7, __v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_95: usize = 2;
+const IN_95: usize = 2;
+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_95], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_95] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        match __v_2.as_canonical_u64() {
+          65535u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_95] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_95] = [__v_10, __v_7];
+            if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 9;
+fn aiur_fn_96(
+  inp: [G; IN_96],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_96], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __v_43: G = __r_arr[2];
+    let __v_44: G = __r_arr[3];
+    let __v_45: G = __r_arr[4];
+    let __v_46: G = __r_arr[5];
+    let __v_47: G = __r_arr[6];
+    let __v_48: G = __r_arr[7];
+    let __v_49: G = __r_arr[8];
+    let __v_50: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __v_70: G = __r_arr[9];
+    let __v_71: G = G::from_u64(0);
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = G::from_u64(0);
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(0);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_96] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
+    if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 13;
+fn aiur_fn_97(
+  inp: [G; IN_97],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_97], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __v_10: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = __r_arr[1];
+    let __v_13: G = __r_arr[2];
+    let __v_14: G = __r_arr[3];
+    let __v_15: G = __r_arr[4];
+    let __v_16: G = __r_arr[5];
+    let __v_17: G = __r_arr[6];
+    let __v_18: G = __r_arr[7];
+    let __v_19: G = __r_arr[8];
+    let __v_20: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+    let __v_22: G = __r_arr[1];
+    let __v_23: G = __r_arr[2];
+    let __v_24: G = __r_arr[3];
+    let __v_25: G = __r_arr[4];
+    let __v_26: G = __r_arr[5];
+    let __v_27: G = __r_arr[6];
+    let __v_28: G = __r_arr[7];
+    let __v_29: G = __r_arr[8];
+    let __v_30: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __v_33: G = __r_arr[2];
+    let __v_34: G = __r_arr[3];
+    let __v_35: G = __r_arr[4];
+    let __v_36: G = __r_arr[5];
+    let __v_37: G = __r_arr[6];
+    let __v_38: G = __r_arr[7];
+    let __v_39: G = __r_arr[8];
+    let __v_40: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __v_43: G = __r_arr[2];
+    let __v_44: G = __r_arr[3];
+    let __v_45: G = __r_arr[4];
+    let __v_46: G = __r_arr[5];
+    let __v_47: G = __r_arr[6];
+    let __v_48: G = __r_arr[7];
+    let __v_49: G = __r_arr[8];
+    let __v_50: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __v_70: G = __r_arr[9];
+    let __v_71: G = G::from_u64(0);
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = G::from_u64(0);
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(0);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_88: G = __r_arr[0];
+    let __v_89: G = __r_arr[1];
+    let __v_90: G = __r_arr[2];
+    let __v_91: G = __r_arr[3];
+    let __v_92: G = __r_arr[4];
+    let __v_93: G = __r_arr[5];
+    let __v_94: G = __r_arr[6];
+    let __v_95: G = __r_arr[7];
+    let __v_96: G = __r_arr[8];
+    let __v_97: G = __r_arr[9];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+    let __v_99: G = __r_arr[1];
+    let __v_100: G = __r_arr[2];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_101: G = __r_arr[0];
+    let __v_102: G = __r_arr[1];
+    let __v_103: G = __r_arr[2];
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+    let __v_105: G = __r_arr[1];
+    let __v_106: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes();
+    let __v_107: G = G::from_u8(__gb[0]);
+    let __v_108: G = G::from_u8(__gb[1]);
+    let __v_109: G = G::from_u8(__gb[2]);
+    let __v_110: G = G::from_u8(__gb[3]);
+    let __v_111: G = G::from_u8(__gb[4]);
+    let __v_112: G = G::from_u8(__gb[5]);
+    let __v_113: G = G::from_u8(__gb[6]);
+    let __v_114: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_107; let __vj = __v_108; 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_109; let __vj = __v_110; 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_111; let __vj = __v_112; 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_113; let __vj = __v_114; 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_115: G = G::from_u64(1020);
+    let __v_116: G = (__v_114 - __v_115);
+    let __v_117: G = (__v_113 + __v_116);
+    let __v_118: G = (__v_112 + __v_117);
+    let __v_119: G = (__v_111 + __v_118);
+    let __v_120: G = G::from_bool((__v_119 == G::ZERO));
+    let __v_121: G = (__v_109 + __v_110);
+    let __v_122: G = (__v_108 + __v_121);
+    let __v_123: G = (__v_107 + __v_122);
+    let __v_124: G = G::from_bool((__v_123 == G::ZERO));
+    let __v_125: G = G::from_u64(256);
+    let __v_126: G = (__v_125 * __v_108);
+    let __v_127: G = G::from_u64(65536);
+    let __v_128: G = (__v_127 * __v_109);
+    let __v_129: G = G::from_u64(16777216);
+    let __v_130: G = (__v_129 * __v_110);
+    let __v_131: G = G::from_u64(4294967296);
+    let __v_132: G = (__v_131 * __v_111);
+    let __v_133: G = G::from_u64(1099511627776);
+    let __v_134: G = (__v_133 * __v_112);
+    let __v_135: G = G::from_u64(281474976710656);
+    let __v_136: G = (__v_135 * __v_113);
+    let __v_137: G = G::from_u64(72057594037927936);
+    let __v_138: G = (__v_137 * __v_114);
+    let __v_139: G = (__v_136 + __v_138);
+    let __v_140: G = (__v_134 + __v_139);
+    let __v_141: G = (__v_132 + __v_140);
+    let __v_142: G = (__v_130 + __v_141);
+    let __v_143: G = (__v_128 + __v_142);
+    let __v_144: G = (__v_126 + __v_143);
+    let __v_145: G = (__v_107 + __v_144);
+    if (__v_145 != __v_106) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+    }
+    let __v_146: G = G::from_u64(1);
+    let __v_147: G = G::from_u64(1);
+    let __v_148: G = (__v_147 - __v_124);
+    let __v_149: G = (__v_120 * __v_148);
+    let __v_150: G = (__v_146 - __v_149);
+    let __v_151: G = G::from_u64(1);
+    if (__v_150 != __v_151) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None });
+    }
+    let __v_152: G = G::from_u64(0);
+    let __v_153: G = G::from_u64(0);
+    let __v_154: G = { let __values: [G; 10] = [__v_153, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_155: G = { let __values: [G; 10] = [__v_152, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_154]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_87, __v_155]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+    let __ret: [G; OUT_97] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_156, __v_98, __v_101, __v_102, __v_104, __v_105];
+    if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_98: usize = 5;
+const IN_98: usize = 5;
+const OUT_98: usize = 1;
+fn aiur_fn_98(
+  inp: [G; IN_98],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_98], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_98] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[98].weight(); } record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_99: usize = 33;
+const IN_99: usize = 33;
+const OUT_99: usize = 1;
+fn aiur_fn_99(
+  inp: [G; IN_99],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_99], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_37: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_39: G = __r_arr[0];
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __v_40: G = __r_arr[0];
+    let __ret: [G; OUT_99] = [__v_40];
+    if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_100: usize = 32;
+const IN_100: usize = 32;
+const OUT_100: usize = 32;
+fn aiur_fn_100(
+  inp: [G; IN_100],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_100], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __ret: [G; OUT_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31];
+    if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_101: usize = 2;
+const IN_101: usize = 2;
+const OUT_101: usize = 1;
+fn aiur_fn_101(
+  inp: [G; IN_101],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_101], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(103);
+    let __v_3: G = G::from_u64(230);
+    let __v_4: G = G::from_u64(9);
+    let __v_5: G = G::from_u64(106);
+    let __v_6: G = G::from_u64(133);
+    let __v_7: G = G::from_u64(174);
+    let __v_8: G = G::from_u64(103);
+    let __v_9: G = G::from_u64(187);
+    let __v_10: G = G::from_u64(114);
+    let __v_11: G = G::from_u64(243);
+    let __v_12: G = G::from_u64(110);
+    let __v_13: G = G::from_u64(60);
+    let __v_14: G = G::from_u64(58);
+    let __v_15: G = G::from_u64(245);
+    let __v_16: G = G::from_u64(79);
+    let __v_17: G = G::from_u64(165);
+    let __v_18: G = G::from_u64(127);
+    let __v_19: G = G::from_u64(82);
+    let __v_20: G = G::from_u64(14);
+    let __v_21: G = G::from_u64(81);
+    let __v_22: G = G::from_u64(140);
+    let __v_23: G = G::from_u64(104);
+    let __v_24: G = G::from_u64(5);
+    let __v_25: G = G::from_u64(155);
+    let __v_26: G = G::from_u64(171);
+    let __v_27: G = G::from_u64(217);
+    let __v_28: G = G::from_u64(131);
+    let __v_29: G = G::from_u64(31);
+    let __v_30: G = G::from_u64(25);
+    let __v_31: G = G::from_u64(205);
+    let __v_32: G = G::from_u64(224);
+    let __v_33: G = G::from_u64(91);
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_66: G = __loaded[0];
+    let __v_67: G = __loaded[1];
+    let __v_68: G = __loaded[2];
+    let __v_69: G = __loaded[3];
+    let __v_70: G = __loaded[4];
+    let __v_71: G = __loaded[5];
+    let __v_72: G = __loaded[6];
+    let __v_73: G = __loaded[7];
+    let __v_74: G = __loaded[8];
+    let __v_75: G = __loaded[9];
+    let __v_76: G = __loaded[10];
+    let __v_77: G = __loaded[11];
+    let __v_78: G = __loaded[12];
+    let __v_79: G = __loaded[13];
+    let __v_80: G = __loaded[14];
+    let __v_81: G = __loaded[15];
+    let __v_82: G = __loaded[16];
+    let __v_83: G = __loaded[17];
+    let __v_84: G = __loaded[18];
+    let __v_85: G = __loaded[19];
+    let __v_86: G = __loaded[20];
+    let __v_87: G = __loaded[21];
+    let __v_88: G = __loaded[22];
+    let __v_89: G = __loaded[23];
+    let __v_90: G = __loaded[24];
+    let __v_91: G = __loaded[25];
+    let __v_92: G = __loaded[26];
+    let __v_93: G = __loaded[27];
+    let __v_94: G = __loaded[28];
+    let __v_95: G = __loaded[29];
+    let __v_96: G = __loaded[30];
+    let __v_97: G = __loaded[31];
+    let __v_98: G = G::from_u64(0);
+    let __v_99: G = G::from_u64(0);
+    let __v_100: G = G::from_u64(0);
+    let __v_101: G = G::from_u64(0);
+    let __v_102: G = G::from_u64(0);
+    let __v_103: G = G::from_u64(0);
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(0);
+    let __v_106: G = G::from_u64(64);
+    let __v_107: G = G::from_u64(11);
+    let __v_108: G = G::from_u64(103);
+    let __v_109: G = G::from_u64(230);
+    let __v_110: G = G::from_u64(9);
+    let __v_111: G = G::from_u64(106);
+    let __v_112: G = G::from_u64(133);
+    let __v_113: G = G::from_u64(174);
+    let __v_114: G = G::from_u64(103);
+    let __v_115: G = G::from_u64(187);
+    let __v_116: G = G::from_u64(114);
+    let __v_117: G = G::from_u64(243);
+    let __v_118: G = G::from_u64(110);
+    let __v_119: G = G::from_u64(60);
+    let __v_120: G = G::from_u64(58);
+    let __v_121: G = G::from_u64(245);
+    let __v_122: G = G::from_u64(79);
+    let __v_123: G = G::from_u64(165);
+    let __v_124: G = G::from_u64(0);
+    let __v_125: G = G::from_u64(0);
+    let __v_126: G = G::from_u64(0);
+    let __v_127: G = G::from_u64(0);
+    let __v_128: G = G::from_u64(0);
+    let __v_129: G = G::from_u64(0);
+    let __v_130: G = G::from_u64(0);
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __v_133: G = __r_arr[2];
+    let __v_134: G = __r_arr[3];
+    let __v_135: G = __r_arr[4];
+    let __v_136: G = __r_arr[5];
+    let __v_137: G = __r_arr[6];
+    let __v_138: G = __r_arr[7];
+    let __v_139: G = __r_arr[8];
+    let __v_140: G = __r_arr[9];
+    let __v_141: G = __r_arr[10];
+    let __v_142: G = __r_arr[11];
+    let __v_143: G = __r_arr[12];
+    let __v_144: G = __r_arr[13];
+    let __v_145: G = __r_arr[14];
+    let __v_146: G = __r_arr[15];
+    let __v_147: G = __r_arr[16];
+    let __v_148: G = __r_arr[17];
+    let __v_149: G = __r_arr[18];
+    let __v_150: G = __r_arr[19];
+    let __v_151: G = __r_arr[20];
+    let __v_152: G = __r_arr[21];
+    let __v_153: G = __r_arr[22];
+    let __v_154: G = __r_arr[23];
+    let __v_155: G = __r_arr[24];
+    let __v_156: G = __r_arr[25];
+    let __v_157: G = __r_arr[26];
+    let __v_158: G = __r_arr[27];
+    let __v_159: G = __r_arr[28];
+    let __v_160: G = __r_arr[29];
+    let __v_161: G = __r_arr[30];
+    let __v_162: G = __r_arr[31];
+    let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_101] = [__v_163];
+    if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_102: usize = 3;
+const IN_102: usize = 3;
+const OUT_102: usize = 1;
+fn aiur_fn_102(
+  inp: [G; IN_102],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_102], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_102] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_102] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_103: usize = 2;
+const IN_103: usize = 2;
+const OUT_103: usize = 1;
+fn aiur_fn_103(
+  inp: [G; IN_103],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_103], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_103] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_3 - __v_1);
+        let __v_6: G = G::from_bool((__v_5 == G::ZERO));
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __ret: [G; OUT_103] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+            let __ret: [G; OUT_103] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_104: usize = 3;
+const IN_104: usize = 3;
+const OUT_104: usize = 1;
+fn aiur_fn_104(
+  inp: [G; IN_104],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_104], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_104] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = (__v_7 - __v_2);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+                let __ret: [G; OUT_104] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                let __v_14: G = __loaded[3];
+                let __v_15: G = __loaded[4];
+                let __v_16: G = __loaded[5];
+                let __v_17: G = __loaded[6];
+                let __v_18: G = __loaded[7];
+                let __v_19: G = __loaded[8];
+                let __v_20: G = __loaded[9];
+                match __v_11.as_canonical_u64() {
+                  1u64 => {
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+                    let __ret: [G; OUT_104] = [__v_21];
+                    if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_21: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_104] = [__v_23];
+                    if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_105: usize = 2;
+const IN_105: usize = 2;
+const OUT_105: usize = 11;
+fn aiur_fn_105(
+  inp: [G; IN_105],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_105], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_12: G = G::from_u64(256);
+        let __v_13: G = (__v_12 * __v_4);
+        let __v_14: G = G::from_u64(65536);
+        let __v_15: G = (__v_14 * __v_5);
+        let __v_16: G = G::from_u64(16777216);
+        let __v_17: G = (__v_16 * __v_6);
+        let __v_18: G = G::from_u64(4294967296);
+        let __v_19: G = (__v_18 * __v_7);
+        let __v_20: G = G::from_u64(1099511627776);
+        let __v_21: G = (__v_20 * __v_8);
+        let __v_22: G = G::from_u64(281474976710656);
+        let __v_23: G = (__v_22 * __v_9);
+        let __v_24: G = G::from_u64(72057594037927936);
+        let __v_25: G = (__v_24 * __v_10);
+        let __v_26: G = (__v_23 + __v_25);
+        let __v_27: G = (__v_21 + __v_26);
+        let __v_28: G = (__v_19 + __v_27);
+        let __v_29: G = (__v_17 + __v_28);
+        let __v_30: G = (__v_15 + __v_29);
+        let __v_31: G = (__v_13 + __v_30);
+        let __v_32: G = (__v_3 + __v_31);
+        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
+        let __v_33: G = G::from_u8(__gb[0]);
+        let __v_34: G = G::from_u8(__gb[1]);
+        let __v_35: G = G::from_u8(__gb[2]);
+        let __v_36: G = G::from_u8(__gb[3]);
+        let __v_37: G = G::from_u8(__gb[4]);
+        let __v_38: G = G::from_u8(__gb[5]);
+        let __v_39: G = G::from_u8(__gb[6]);
+        let __v_40: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_41: G = G::from_u64(1020);
+        let __v_42: G = (__v_40 - __v_41);
+        let __v_43: G = (__v_39 + __v_42);
+        let __v_44: G = (__v_38 + __v_43);
+        let __v_45: G = (__v_37 + __v_44);
+        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
+        let __v_47: G = (__v_35 + __v_36);
+        let __v_48: G = (__v_34 + __v_47);
+        let __v_49: G = (__v_33 + __v_48);
+        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
+        let __v_51: G = G::from_u64(256);
+        let __v_52: G = (__v_51 * __v_34);
+        let __v_53: G = G::from_u64(65536);
+        let __v_54: G = (__v_53 * __v_35);
+        let __v_55: G = G::from_u64(16777216);
+        let __v_56: G = (__v_55 * __v_36);
+        let __v_57: G = G::from_u64(4294967296);
+        let __v_58: G = (__v_57 * __v_37);
+        let __v_59: G = G::from_u64(1099511627776);
+        let __v_60: G = (__v_59 * __v_38);
+        let __v_61: G = G::from_u64(281474976710656);
+        let __v_62: G = (__v_61 * __v_39);
+        let __v_63: G = G::from_u64(72057594037927936);
+        let __v_64: G = (__v_63 * __v_40);
+        let __v_65: G = (__v_62 + __v_64);
+        let __v_66: G = (__v_60 + __v_65);
+        let __v_67: G = (__v_58 + __v_66);
+        let __v_68: G = (__v_56 + __v_67);
+        let __v_69: G = (__v_54 + __v_68);
+        let __v_70: G = (__v_52 + __v_69);
+        let __v_71: G = (__v_33 + __v_70);
+        if (__v_71 != __v_32) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+        }
+        let __v_72: G = G::from_u64(1);
+        let __v_73: G = G::from_u64(1);
+        let __v_74: G = (__v_73 - __v_50);
+        let __v_75: G = (__v_46 * __v_74);
+        let __v_76: G = (__v_72 - __v_75);
+        let __v_77: G = G::from_u64(1);
+        if (__v_76 != __v_77) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+        }
+        let __v_78: G = G::from_u64(1);
+        let __ret: [G; OUT_105] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
+        if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_12: G = __loaded[0];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
+            if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_13, __v_14]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+            let __v_16: G = __r_arr[1];
+            let __v_17: G = __r_arr[2];
+            let __v_18: G = __r_arr[3];
+            let __v_19: G = __r_arr[4];
+            let __v_20: G = __r_arr[5];
+            let __v_21: G = __r_arr[6];
+            let __v_22: G = __r_arr[7];
+            let __v_23: G = __r_arr[8];
+            let __v_24: G = __r_arr[9];
+            let __v_25: G = __r_arr[10];
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_106: usize = 6;
+const IN_106: usize = 6;
+const OUT_106: usize = 1;
+fn aiur_fn_106(
+  inp: [G; IN_106],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_106], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+    let __v_7: G = __r_arr[1];
+    let __v_8: G = __r_arr[2];
+    let __v_9: G = __r_arr[3];
+    let __v_10: G = __r_arr[4];
+    let __v_11: G = __r_arr[5];
+    let __v_12: G = __r_arr[6];
+    let __v_13: G = __r_arr[7];
+    let __v_14: G = __r_arr[8];
+    let __v_15: G = __r_arr[9];
+    let __v_16: G = __r_arr[10];
+    match __v_16.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_17: G = __loaded[0];
+        let __v_18: G = __loaded[1];
+        let __v_19: G = __loaded[2];
+        let __v_20: G = __loaded[3];
+        let __v_21: G = __loaded[4];
+        let __v_22: G = __loaded[5];
+        let __v_23: G = __loaded[6];
+        let __v_24: G = __loaded[7];
+        match __v_17.as_canonical_u64() {
+          0u64 => {
+            match __v_18.as_canonical_u64() {
+              0u64 => {
+                match __v_19.as_canonical_u64() {
+                  0u64 => {
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        match __v_21.as_canonical_u64() {
+                          0u64 => {
+                            match __v_22.as_canonical_u64() {
+                              0u64 => {
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    match __v_24.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                        let __v_25: G = __loaded[0];
+                                        let __v_26: G = __loaded[1];
+                                        let __v_27: G = __loaded[2];
+                                        let __v_28: G = __loaded[3];
+                                        let __v_29: G = __loaded[4];
+                                        let __v_30: G = __loaded[5];
+                                        let __v_31: G = __loaded[6];
+                                        let __v_32: G = __loaded[7];
+                                        let __v_33: G = __loaded[8];
+                                        let __v_34: G = __loaded[9];
+                                        let __v_35: G = __loaded[10];
+                                        let __v_36: G = __loaded[11];
+                                        let __v_37: G = __loaded[12];
+                                        let __v_38: G = __loaded[13];
+                                        let __v_39: G = __loaded[14];
+                                        let __v_40: G = __loaded[15];
+                                        let __v_41: G = __loaded[16];
+                                        let __v_42: G = __loaded[17];
+                                        let __v_43: G = __loaded[18];
+                                        let __v_44: G = __loaded[19];
+                                        let __v_45: G = __loaded[20];
+                                        let __v_46: G = __loaded[21];
+                                        let __v_47: G = __loaded[22];
+                                        let __v_48: G = __loaded[23];
+                                        let __v_49: G = __loaded[24];
+                                        let __v_50: G = __loaded[25];
+                                        let __v_51: G = __loaded[26];
+                                        let __v_52: G = __loaded[27];
+                                        let __v_53: G = __loaded[28];
+                                        let __v_54: G = __loaded[29];
+                                        let __v_55: G = __loaded[30];
+                                        let __v_56: G = __loaded[31];
+                                        let __v_57: G = G::from_u64(0);
+                                        let __v_58: G = G::from_u64(0);
+                                        let __v_59: G = G::from_u64(0);
+                                        let __v_60: G = G::from_u64(0);
+                                        let __v_61: G = G::from_u64(0);
+                                        let __v_62: G = G::from_u64(0);
+                                        let __v_63: G = G::from_u64(0);
+                                        let __v_64: G = G::from_u64(0);
+                                        let __v_65: G = G::from_u64(0);
+                                        let __v_66: G = G::from_u64(0);
+                                        let __v_67: G = G::from_u64(0);
+                                        let __v_68: G = G::from_u64(0);
+                                        let __v_69: G = G::from_u64(0);
+                                        let __v_70: G = G::from_u64(0);
+                                        let __v_71: G = G::from_u64(0);
+                                        let __v_72: G = G::from_u64(0);
+                                        let __v_73: G = G::from_u64(0);
+                                        let __v_74: G = G::from_u64(0);
+                                        let __v_75: G = G::from_u64(0);
+                                        let __v_76: G = G::from_u64(0);
+                                        let __v_77: G = G::from_u64(0);
+                                        let __v_78: G = G::from_u64(0);
+                                        let __v_79: G = G::from_u64(0);
+                                        let __v_80: G = G::from_u64(0);
+                                        let __v_81: G = G::from_u64(0);
+                                        let __v_82: G = G::from_u64(0);
+                                        let __v_83: G = G::from_u64(0);
+                                        let __v_84: G = G::from_u64(0);
+                                        let __v_85: G = G::from_u64(0);
+                                        let __v_86: G = G::from_u64(0);
+                                        let __v_87: G = G::from_u64(0);
+                                        let __v_88: G = G::from_u64(0);
+                                        let __v_89: G = G::from_u64(0);
+                                        let __v_90: G = G::from_u64(0);
+                                        let __v_91: G = G::from_u64(0);
+                                        let __v_92: G = G::from_u64(0);
+                                        let __v_93: G = G::from_u64(0);
+                                        let __v_94: G = G::from_u64(0);
+                                        let __v_95: G = G::from_u64(0);
+                                        let __v_96: G = G::from_u64(0);
+                                        let __v_97: G = G::from_u64(0);
+                                        let __v_98: G = G::from_u64(0);
+                                        let __v_99: G = G::from_u64(0);
+                                        let __v_100: G = G::from_u64(0);
+                                        let __v_101: G = G::from_u64(0);
+                                        let __v_102: G = G::from_u64(0);
+                                        let __v_103: G = G::from_u64(0);
+                                        let __v_104: G = G::from_u64(0);
+                                        let __v_105: G = G::from_u64(0);
+                                        let __v_106: G = G::from_u64(0);
+                                        let __v_107: G = G::from_u64(0);
+                                        let __v_108: G = G::from_u64(0);
+                                        let __v_109: G = G::from_u64(0);
+                                        let __v_110: G = G::from_u64(0);
+                                        let __v_111: G = G::from_u64(0);
+                                        let __v_112: G = G::from_u64(0);
+                                        let __v_113: G = G::from_u64(0);
+                                        let __v_114: G = G::from_u64(0);
+                                        let __v_115: G = G::from_u64(0);
+                                        let __v_116: G = G::from_u64(0);
+                                        let __v_117: G = G::from_u64(0);
+                                        let __v_118: G = G::from_u64(0);
+                                        let __v_119: G = G::from_u64(0);
+                                        let __v_120: G = G::from_u64(0);
+                                        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __v_121: G = __loaded[0];
+                                        let __v_122: G = __loaded[1];
+                                        let __v_123: G = __loaded[2];
+                                        let __v_124: G = __loaded[3];
+                                        let __v_125: G = __loaded[4];
+                                        let __v_126: G = __loaded[5];
+                                        let __v_127: G = __loaded[6];
+                                        let __v_128: G = __loaded[7];
+                                        let __v_129: G = G::from_u64(0);
+                                        let __v_130: G = G::from_u64(11);
+                                        let __v_131: G = G::from_u64(103);
+                                        let __v_132: G = G::from_u64(230);
+                                        let __v_133: G = G::from_u64(9);
+                                        let __v_134: G = G::from_u64(106);
+                                        let __v_135: G = G::from_u64(133);
+                                        let __v_136: G = G::from_u64(174);
+                                        let __v_137: G = G::from_u64(103);
+                                        let __v_138: G = G::from_u64(187);
+                                        let __v_139: G = G::from_u64(114);
+                                        let __v_140: G = G::from_u64(243);
+                                        let __v_141: G = G::from_u64(110);
+                                        let __v_142: G = G::from_u64(60);
+                                        let __v_143: G = G::from_u64(58);
+                                        let __v_144: G = G::from_u64(245);
+                                        let __v_145: G = G::from_u64(79);
+                                        let __v_146: G = G::from_u64(165);
+                                        let __v_147: G = G::from_u64(0);
+                                        let __v_148: G = G::from_u64(0);
+                                        let __v_149: G = G::from_u64(0);
+                                        let __v_150: G = G::from_u64(0);
+                                        let __v_151: G = G::from_u64(0);
+                                        let __v_152: G = G::from_u64(0);
+                                        let __v_153: G = G::from_u64(0);
+                                        let __v_154: G = G::from_u64(0);
+                                        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
+                                        let __v_156: G = __r_arr[1];
+                                        let __v_157: G = __r_arr[2];
+                                        let __v_158: G = __r_arr[3];
+                                        let __v_159: G = __r_arr[4];
+                                        let __v_160: G = __r_arr[5];
+                                        let __v_161: G = __r_arr[6];
+                                        let __v_162: G = __r_arr[7];
+                                        let __v_163: G = __r_arr[8];
+                                        let __v_164: G = __r_arr[9];
+                                        let __v_165: G = __r_arr[10];
+                                        let __v_166: G = __r_arr[11];
+                                        let __v_167: G = __r_arr[12];
+                                        let __v_168: G = __r_arr[13];
+                                        let __v_169: G = __r_arr[14];
+                                        let __v_170: G = __r_arr[15];
+                                        let __v_171: G = __r_arr[16];
+                                        let __v_172: G = __r_arr[17];
+                                        let __v_173: G = __r_arr[18];
+                                        let __v_174: G = __r_arr[19];
+                                        let __v_175: G = __r_arr[20];
+                                        let __v_176: G = __r_arr[21];
+                                        let __v_177: G = __r_arr[22];
+                                        let __v_178: G = __r_arr[23];
+                                        let __v_179: G = __r_arr[24];
+                                        let __v_180: G = __r_arr[25];
+                                        let __v_181: G = __r_arr[26];
+                                        let __v_182: G = __r_arr[27];
+                                        let __v_183: G = __r_arr[28];
+                                        let __v_184: G = __r_arr[29];
+                                        let __v_185: G = __r_arr[30];
+                                        let __v_186: G = __r_arr[31];
+                                        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __ret: [G; OUT_106] = [__v_187];
+                                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __ret: [G; OUT_106] = [__v_5];
+                                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    let __ret: [G; OUT_106] = [__v_5];
+                                    if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __ret: [G; OUT_106] = [__v_5];
+                                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                          _ => {
+                            let __ret: [G; OUT_106] = [__v_5];
+                            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        let __ret: [G; OUT_106] = [__v_5];
+                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __ret: [G; OUT_106] = [__v_5];
+                    if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __ret: [G; OUT_106] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __ret: [G; OUT_106] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14, __v_15]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+        let __v_18: G = __r_arr[1];
+        let __v_19: G = __r_arr[2];
+        let __v_20: G = __r_arr[3];
+        let __v_21: G = __r_arr[4];
+        let __v_22: G = __r_arr[5];
+        let __v_23: G = __r_arr[6];
+        let __v_24: G = __r_arr[7];
+        let __v_25: G = __r_arr[8];
+        let __v_26: G = __r_arr[9];
+        let __v_27: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_25, __v_26]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+        let __v_29: G = __r_arr[1];
+        let __v_30: G = __r_arr[2];
+        let __v_31: G = __r_arr[3];
+        let __v_32: G = __r_arr[4];
+        let __v_33: G = __r_arr[5];
+        let __v_34: G = __r_arr[6];
+        let __v_35: G = __r_arr[7];
+        let __v_36: G = __r_arr[8];
+        let __v_37: G = __r_arr[9];
+        let __v_38: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_36, __v_37]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+        let __v_40: G = __r_arr[1];
+        let __v_41: G = __r_arr[2];
+        let __v_42: G = __r_arr[3];
+        let __v_43: G = __r_arr[4];
+        let __v_44: G = __r_arr[5];
+        let __v_45: G = __r_arr[6];
+        let __v_46: G = __r_arr[7];
+        let __v_47: G = __r_arr[8];
+        let __v_48: G = __r_arr[9];
+        let __v_49: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
+        let __v_51: G = __r_arr[1];
+        let __v_52: G = __r_arr[2];
+        let __v_53: G = __r_arr[3];
+        let __v_54: G = __r_arr[4];
+        let __v_55: G = __r_arr[5];
+        let __v_56: G = __r_arr[6];
+        let __v_57: G = __r_arr[7];
+        let __v_58: G = __r_arr[8];
+        let __v_59: G = __r_arr[9];
+        let __v_60: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_58, __v_59]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+        let __v_62: G = __r_arr[1];
+        let __v_63: G = __r_arr[2];
+        let __v_64: G = __r_arr[3];
+        let __v_65: G = __r_arr[4];
+        let __v_66: G = __r_arr[5];
+        let __v_67: G = __r_arr[6];
+        let __v_68: G = __r_arr[7];
+        let __v_69: G = __r_arr[8];
+        let __v_70: G = __r_arr[9];
+        let __v_71: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_69, __v_70]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
+        let __v_73: G = __r_arr[1];
+        let __v_74: G = __r_arr[2];
+        let __v_75: G = __r_arr[3];
+        let __v_76: G = __r_arr[4];
+        let __v_77: G = __r_arr[5];
+        let __v_78: G = __r_arr[6];
+        let __v_79: G = __r_arr[7];
+        let __v_80: G = __r_arr[8];
+        let __v_81: G = __r_arr[9];
+        let __v_82: G = __r_arr[10];
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_80, __v_81]; let __cu = unconstrained; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+        let __v_84: G = __r_arr[1];
+        let __v_85: G = __r_arr[2];
+        let __v_86: G = __r_arr[3];
+        let __v_87: G = __r_arr[4];
+        let __v_88: G = __r_arr[5];
+        let __v_89: G = __r_arr[6];
+        let __v_90: G = __r_arr[7];
+        let __v_91: G = __r_arr[8];
+        let __v_92: G = __r_arr[9];
+        let __v_93: G = __r_arr[10];
+        let __v_94: G = G::from_u64(8);
+        let __v_95: G = (__v_82 + __v_93);
+        let __v_96: G = (__v_71 + __v_95);
+        let __v_97: G = (__v_60 + __v_96);
+        let __v_98: G = (__v_49 + __v_97);
+        let __v_99: G = (__v_38 + __v_98);
+        let __v_100: G = (__v_27 + __v_99);
+        let __v_101: G = (__v_16 + __v_100);
+        let __v_102: G = (__v_94 * __v_101);
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        let __v_106: G = __loaded[3];
+        let __v_107: G = __loaded[4];
+        let __v_108: G = __loaded[5];
+        let __v_109: G = __loaded[6];
+        let __v_110: G = __loaded[7];
+        let __v_111: G = __loaded[8];
+        let __v_112: G = __loaded[9];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
+  1u64 => {
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_113: G = __loaded[0];
+    let __v_114: G = __loaded[1];
+    let __v_115: G = __loaded[2];
+    match __v_113.as_canonical_u64() {
+      1u64 => {
+        let __v_116: G = G::from_u64(1);
+        break '__mc_0 [__v_116];
+      },
+      _ => {
+        let __v_116: G = G::from_u64(0);
+        break '__mc_0 [__v_116];
+      },
+    }
+  },
+  _ => {
+    let __v_113: G = G::from_u64(0);
+    break '__mc_0 [__v_113];
+  },
+}
+ };
+        let __v_113: G = __mc_out___mc_0[0];
+        let __v_114: G = G::from_u64(15);
+        let __v_115: G = (__v_2 - __v_114);
+        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
+        let __v_117: G = G::from_bool((__v_2 == G::ZERO));
+        let __v_118: G = (__v_113 * __v_116);
+        let __v_119: G = (__v_116 - __v_118);
+        let __v_120: G = (__v_113 + __v_119);
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_121: G = __loaded[0];
+        let __v_122: G = __loaded[1];
+        let __v_123: G = __loaded[2];
+        let __v_124: G = __loaded[3];
+        let __v_125: G = __loaded[4];
+        let __v_126: G = __loaded[5];
+        let __v_127: G = __loaded[6];
+        let __v_128: G = __loaded[7];
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
+        let __v_130: G = (__v_113 * __v_129);
+        let __v_131: G = G::from_u64(2);
+        let __v_132: G = (__v_131 * __v_120);
+        let __v_133: G = G::from_u64(8);
+        let __v_134: G = (__v_133 * __v_130);
+        let __v_135: G = (__v_132 + __v_134);
+        let __v_136: G = (__v_117 + __v_135);
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_137: G = __loaded[0];
+        let __v_138: G = __loaded[1];
+        let __v_139: G = __loaded[2];
+        let __v_140: G = __loaded[3];
+        let __v_141: G = __loaded[4];
+        let __v_142: G = __loaded[5];
+        let __v_143: G = __loaded[6];
+        let __v_144: G = __loaded[7];
+        let __v_145: G = __loaded[8];
+        let __v_146: G = __loaded[9];
+        let __v_147: G = __loaded[10];
+        let __v_148: G = __loaded[11];
+        let __v_149: G = __loaded[12];
+        let __v_150: G = __loaded[13];
+        let __v_151: G = __loaded[14];
+        let __v_152: G = __loaded[15];
+        let __v_153: G = __loaded[16];
+        let __v_154: G = __loaded[17];
+        let __v_155: G = __loaded[18];
+        let __v_156: G = __loaded[19];
+        let __v_157: G = __loaded[20];
+        let __v_158: G = __loaded[21];
+        let __v_159: G = __loaded[22];
+        let __v_160: G = __loaded[23];
+        let __v_161: G = __loaded[24];
+        let __v_162: G = __loaded[25];
+        let __v_163: G = __loaded[26];
+        let __v_164: G = __loaded[27];
+        let __v_165: G = __loaded[28];
+        let __v_166: G = __loaded[29];
+        let __v_167: G = __loaded[30];
+        let __v_168: G = __loaded[31];
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __v_169: G = __loaded[0];
+        let __v_170: G = __loaded[1];
+        let __v_171: G = __loaded[2];
+        let __v_172: G = __loaded[3];
+        let __v_173: G = __loaded[4];
+        let __v_174: G = __loaded[5];
+        let __v_175: G = __loaded[6];
+        let __v_176: G = __loaded[7];
+        let __v_177: G = G::from_u64(103);
+        let __v_178: G = G::from_u64(230);
+        let __v_179: G = G::from_u64(9);
+        let __v_180: G = G::from_u64(106);
+        let __v_181: G = G::from_u64(133);
+        let __v_182: G = G::from_u64(174);
+        let __v_183: G = G::from_u64(103);
+        let __v_184: G = G::from_u64(187);
+        let __v_185: G = G::from_u64(114);
+        let __v_186: G = G::from_u64(243);
+        let __v_187: G = G::from_u64(110);
+        let __v_188: G = G::from_u64(60);
+        let __v_189: G = G::from_u64(58);
+        let __v_190: G = G::from_u64(245);
+        let __v_191: G = G::from_u64(79);
+        let __v_192: G = G::from_u64(165);
+        let __v_193: G = G::from_u64(0);
+        let __v_194: G = G::from_u64(0);
+        let __v_195: G = G::from_u64(0);
+        let __v_196: G = G::from_u64(0);
+        let __v_197: G = G::from_u64(0);
+        let __v_198: G = G::from_u64(0);
+        let __v_199: G = G::from_u64(0);
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_200: G = __r_arr[0];
+        let __v_201: G = __r_arr[1];
+        let __v_202: G = __r_arr[2];
+        let __v_203: G = __r_arr[3];
+        let __v_204: G = __r_arr[4];
+        let __v_205: G = __r_arr[5];
+        let __v_206: G = __r_arr[6];
+        let __v_207: G = __r_arr[7];
+        let __v_208: G = __r_arr[8];
+        let __v_209: G = __r_arr[9];
+        let __v_210: G = __r_arr[10];
+        let __v_211: G = __r_arr[11];
+        let __v_212: G = __r_arr[12];
+        let __v_213: G = __r_arr[13];
+        let __v_214: G = __r_arr[14];
+        let __v_215: G = __r_arr[15];
+        let __v_216: G = __r_arr[16];
+        let __v_217: G = __r_arr[17];
+        let __v_218: G = __r_arr[18];
+        let __v_219: G = __r_arr[19];
+        let __v_220: G = __r_arr[20];
+        let __v_221: G = __r_arr[21];
+        let __v_222: G = __r_arr[22];
+        let __v_223: G = __r_arr[23];
+        let __v_224: G = __r_arr[24];
+        let __v_225: G = __r_arr[25];
+        let __v_226: G = __r_arr[26];
+        let __v_227: G = __r_arr[27];
+        let __v_228: G = __r_arr[28];
+        let __v_229: G = __r_arr[29];
+        let __v_230: G = __r_arr[30];
+        let __v_231: G = __r_arr[31];
+        match __v_113.as_canonical_u64() {
+          1u64 => {
+            let __v_232: G = G::from_u64(0);
+            let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_106] = [__v_233];
+            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            match __v_116.as_canonical_u64() {
+              1u64 => {
+                let __v_232: G = G::from_u64(103);
+                let __v_233: G = G::from_u64(230);
+                let __v_234: G = G::from_u64(9);
+                let __v_235: G = G::from_u64(106);
+                let __v_236: G = G::from_u64(133);
+                let __v_237: G = G::from_u64(174);
+                let __v_238: G = G::from_u64(103);
+                let __v_239: G = G::from_u64(187);
+                let __v_240: G = G::from_u64(114);
+                let __v_241: G = G::from_u64(243);
+                let __v_242: G = G::from_u64(110);
+                let __v_243: G = G::from_u64(60);
+                let __v_244: G = G::from_u64(58);
+                let __v_245: G = G::from_u64(245);
+                let __v_246: G = G::from_u64(79);
+                let __v_247: G = G::from_u64(165);
+                let __v_248: G = G::from_u64(127);
+                let __v_249: G = G::from_u64(82);
+                let __v_250: G = G::from_u64(14);
+                let __v_251: G = G::from_u64(81);
+                let __v_252: G = G::from_u64(140);
+                let __v_253: G = G::from_u64(104);
+                let __v_254: G = G::from_u64(5);
+                let __v_255: G = G::from_u64(155);
+                let __v_256: G = G::from_u64(171);
+                let __v_257: G = G::from_u64(217);
+                let __v_258: G = G::from_u64(131);
+                let __v_259: G = G::from_u64(31);
+                let __v_260: G = G::from_u64(25);
+                let __v_261: G = G::from_u64(205);
+                let __v_262: G = G::from_u64(224);
+                let __v_263: G = G::from_u64(91);
+                let __v_264: G = G::from_u64(0);
+                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                let __v_265: G = __loaded[0];
+                let __v_266: G = __loaded[1];
+                let __v_267: G = __loaded[2];
+                let __v_268: G = __loaded[3];
+                let __v_269: G = __loaded[4];
+                let __v_270: G = __loaded[5];
+                let __v_271: G = __loaded[6];
+                let __v_272: G = __loaded[7];
+                let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[12].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } };
+                let __v_273: G = __r_arr[0];
+                let __v_274: G = __r_arr[1];
+                let __v_275: G = __r_arr[2];
+                let __v_276: G = __r_arr[3];
+                let __v_277: G = __r_arr[4];
+                let __v_278: G = __r_arr[5];
+                let __v_279: G = __r_arr[6];
+                let __v_280: G = __r_arr[7];
+                let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_282: G = { let __values: [G; 32] = [__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, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_283: G = G::from_u64(0);
+                let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_285: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_285];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_232: G = G::from_u64(1);
+                let __v_233: G = (__v_2 + __v_232);
+                let __v_234: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_235: G = __r_arr[0];
+                let __ret: [G; OUT_106] = [__v_235];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 32;
+fn aiur_fn_107(
+  inp: [G; IN_107],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_107], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __v_52: G = __r_arr[1];
+    let __v_53: G = __r_arr[2];
+    let __v_54: G = __r_arr[3];
+    let __v_55: G = __r_arr[4];
+    let __v_56: G = __r_arr[5];
+    let __v_57: G = __r_arr[6];
+    let __v_58: G = __r_arr[7];
+    let __v_59: G = __r_arr[8];
+    let __v_60: G = __r_arr[9];
+    let __v_61: G = __r_arr[10];
+    let __v_62: G = __r_arr[11];
+    let __v_63: G = __r_arr[12];
+    let __v_64: G = __r_arr[13];
+    let __v_65: G = __r_arr[14];
+    let __v_66: G = __r_arr[15];
+    let __v_67: G = __r_arr[16];
+    let __v_68: G = __r_arr[17];
+    let __v_69: G = __r_arr[18];
+    let __v_70: G = __r_arr[19];
+    let __v_71: G = __r_arr[20];
+    let __v_72: G = __r_arr[21];
+    let __v_73: G = __r_arr[22];
+    let __v_74: G = __r_arr[23];
+    let __v_75: G = __r_arr[24];
+    let __v_76: G = __r_arr[25];
+    let __v_77: G = __r_arr[26];
+    let __v_78: G = __r_arr[27];
+    let __v_79: G = __r_arr[28];
+    let __v_80: G = __r_arr[29];
+    let __v_81: G = __r_arr[30];
+    let __v_82: G = __r_arr[31];
+    let __ret: [G; OUT_107] = [__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];
+    if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_108: usize = 3;
+const IN_108: usize = 3;
+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_108], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = G::from_u64(103);
+    let __v_5: G = G::from_u64(230);
+    let __v_6: G = G::from_u64(9);
+    let __v_7: G = G::from_u64(106);
+    let __v_8: G = G::from_u64(133);
+    let __v_9: G = G::from_u64(174);
+    let __v_10: G = G::from_u64(103);
+    let __v_11: G = G::from_u64(187);
+    let __v_12: G = G::from_u64(114);
+    let __v_13: G = G::from_u64(243);
+    let __v_14: G = G::from_u64(110);
+    let __v_15: G = G::from_u64(60);
+    let __v_16: G = G::from_u64(58);
+    let __v_17: G = G::from_u64(245);
+    let __v_18: G = G::from_u64(79);
+    let __v_19: G = G::from_u64(165);
+    let __v_20: G = G::from_u64(127);
+    let __v_21: G = G::from_u64(82);
+    let __v_22: G = G::from_u64(14);
+    let __v_23: G = G::from_u64(81);
+    let __v_24: G = G::from_u64(140);
+    let __v_25: G = G::from_u64(104);
+    let __v_26: G = G::from_u64(5);
+    let __v_27: G = G::from_u64(155);
+    let __v_28: G = G::from_u64(171);
+    let __v_29: G = G::from_u64(217);
+    let __v_30: G = G::from_u64(131);
+    let __v_31: G = G::from_u64(31);
+    let __v_32: G = G::from_u64(25);
+    let __v_33: G = G::from_u64(205);
+    let __v_34: G = G::from_u64(224);
+    let __v_35: G = G::from_u64(91);
+    let __v_36: G = G::from_u64(1);
+    let __v_37: G = G::from_u64(1);
+    let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_50: G = G::from_u64(1);
+    let __v_51: G = G::from_u64(1);
+    let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_38, __v_3, __v_39, __v_48, __v_49, __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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_53: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
+    let __v_55: G = __r_arr[1];
+    let __v_56: G = __r_arr[2];
+    let __v_57: G = __r_arr[3];
+    let __v_58: G = __r_arr[4];
+    let __v_59: G = __r_arr[5];
+    let __v_60: G = __r_arr[6];
+    let __v_61: G = __r_arr[7];
+    let __v_62: G = __r_arr[8];
+    let __v_63: G = __r_arr[9];
+    let __v_64: G = __r_arr[10];
+    let __v_65: G = __r_arr[11];
+    let __v_66: G = __r_arr[12];
+    let __v_67: G = __r_arr[13];
+    let __v_68: G = __r_arr[14];
+    let __v_69: G = __r_arr[15];
+    let __v_70: G = __r_arr[16];
+    let __v_71: G = __r_arr[17];
+    let __v_72: G = __r_arr[18];
+    let __v_73: G = __r_arr[19];
+    let __v_74: G = __r_arr[20];
+    let __v_75: G = __r_arr[21];
+    let __v_76: G = __r_arr[22];
+    let __v_77: G = __r_arr[23];
+    let __v_78: G = __r_arr[24];
+    let __v_79: G = __r_arr[25];
+    let __v_80: G = __r_arr[26];
+    let __v_81: G = __r_arr[27];
+    let __v_82: G = __r_arr[28];
+    let __v_83: G = __r_arr[29];
+    let __v_84: G = __r_arr[30];
+    let __v_85: G = __r_arr[31];
+    let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_108] = [__v_86];
+    if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_109: usize = 4;
+const IN_109: usize = 4;
+const OUT_109: usize = 1;
+fn aiur_fn_109(
+  inp: [G; IN_109],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_109], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_103] = { let __args: [G; IN_103] = [__v_1, __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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_109] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_109] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 1;
+fn aiur_fn_110(
+  inp: [G; IN_110],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_110], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_110] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(2);
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3]; let __cu = unconstrained; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_2 + __v_6);
+        let __ret: [G; OUT_110] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_111: usize = 2;
+const IN_111: usize = 2;
+const OUT_111: usize = 1;
+fn aiur_fn_111(
+  inp: [G; IN_111],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_111], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_111] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __v_13: G = __loaded[5];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_111] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            match __v_3.as_canonical_u64() {
+              _ => {
+                match __v_9.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; 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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+                    match __v_14.as_canonical_u64() {
+                      1u64 => {
+                        let __v_15: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7, __v_1]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+                        let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_111] = [__v_17];
+                        if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_15: G = (__v_3 - __v_9);
+                        let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+                        match __v_16.as_canonical_u64() {
+                          1u64 => {
+                            if (__v_6 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+                            }
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7, __v_13]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __ret: [G; OUT_111] = [__v_19];
+                            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __ret: [G; OUT_111] = [__v_19];
+                            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 2;
+fn aiur_fn_112(
+  inp: [G; IN_112],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_112], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_112] = [__v_9, __v_12];
+        if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_18: G = G::from_u64(1);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_112] = [__v_17, __v_20];
+            if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_112] = [__v_16, __v_18];
+            if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 1;
+fn aiur_fn_113(
+  inp: [G; IN_113],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_113], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_113] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_113] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_15, __v_16]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __ret: [G; OUT_113] = [__v_17];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_114: usize = 4;
+const IN_114: usize = 4;
+const OUT_114: usize = 1;
+fn aiur_fn_114(
+  inp: [G; IN_114],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_114], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(0);
+        if (__v_7 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+        }
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_114] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_2, __v_3]; 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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+            let __v_11: G = G::from_u64(0);
+            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_5]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6, __v_9, __v_2, __v_3]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_114] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_115: usize = 4;
+const IN_115: usize = 4;
+const OUT_115: usize = 2;
+fn aiur_fn_115(
+  inp: [G; IN_115],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_115], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_115] = [__v_12, __v_1];
+        if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                let __v_14: G = __loaded[0];
+                let __v_15: G = __loaded[1];
+                let __v_16: G = __loaded[2];
+                let __v_17: G = __loaded[3];
+                let __v_18: G = __loaded[4];
+                let __v_19: G = __loaded[5];
+                match __v_14.as_canonical_u64() {
+                  0u64 => {
+                    match __v_15.as_canonical_u64() {
+                      _ => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                        let __v_21: G = __loaded[1];
+                        let __v_22: G = __loaded[2];
+                        match __v_20.as_canonical_u64() {
+                          0u64 => {
+                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_22]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+                            let __v_24: G = (__v_13 - __v_23);
+                            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+                            match __v_25.as_canonical_u64() {
+                              1u64 => {
+                                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+                                let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_26]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+                                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_19, __v_1, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_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; 6] = [__v_30, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __ret: [G; OUT_115] = [__v_31, __v_29];
+                                if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_26: G = __loaded[0];
+                                let __v_27: G = __loaded[1];
+                                let __v_28: G = __loaded[2];
+                                match __v_26.as_canonical_u64() {
+                                  0u64 => {
+                                    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; 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 { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_29]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9, __v_28, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                                    let __v_32: G = __r_arr[1];
+                                    let __v_33: G = G::from_u64(0);
+                                    let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                    let __ret: [G; OUT_115] = [__v_34, __v_32];
+                                    if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                          },
+                        }
+                      },
+                    }
+                  },
+                  1u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; 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 { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+                        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_23]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+                        let __v_25: G = G::from_u64(0);
+                        let __v_26: G = G::from_u64(1);
+                        let __v_27: G = G::from_u64(1);
+                        let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_115] = [__v_29, __v_22];
+                        if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_116: usize = 4;
+const IN_116: usize = 4;
+const OUT_116: usize = 2;
+fn aiur_fn_116(
+  inp: [G; IN_116],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_116], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_116] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_3 - __v_4);
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_3 - __v_8);
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_6, __v_7, __v_2, __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 { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_116] = [__v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_117: usize = 6;
+const IN_117: usize = 6;
+const OUT_117: usize = 1;
+fn aiur_fn_117(
+  inp: [G; IN_117],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_117], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_114] = { let __args: [G; IN_114] = [__v_3, __v_1, __v_2, __v_5]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_4, __v_2, __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 { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_10: G = __loaded[0];
+    let __v_11: G = __loaded[1];
+    let __v_12: G = __loaded[2];
+    let __v_13: G = __loaded[3];
+    let __v_14: G = __loaded[4];
+    let __v_15: G = __loaded[5];
+    match __v_10.as_canonical_u64() {
+      0u64 => {
+        match __v_11.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __v_18: G = (__v_16 - __v_17);
+            let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+            let __v_20: G = G::from_u64(1);
+            if (__v_19 != __v_20) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = G::from_u64(0);
+            if (__v_21 != __v_22) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__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 { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } 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_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: None });
+            }
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+            let __v_26: G = (__v_25 - __v_14);
+            let __v_27: G = G::from_bool((__v_26 == G::ZERO));
+            let __ret: [G; OUT_117] = [__v_27];
+            if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_118: usize = 2;
+const IN_118: usize = 2;
+const OUT_118: usize = 1;
+fn aiur_fn_118(
+  inp: [G; IN_118],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_118], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_118] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_6]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_118] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_119: usize = 2;
+const IN_119: usize = 2;
+const OUT_119: usize = 1;
+fn aiur_fn_119(
+  inp: [G; IN_119],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_119], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_119] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_5, __v_4]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_119] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_7: G = (__v_0 * __v_6);
+            let __ret: [G; OUT_119] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_120: usize = 8;
+const IN_120: usize = 8;
+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_120], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = (__v_1 + __v_8);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_9]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0, __v_13]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10, __v_14]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = (__v_15 + __v_15);
+    let __v_17: G = (__v_4 + __v_6);
+    let __v_18: G = (__v_5 + __v_7);
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_19 * __v_19);
+    let __v_22: G = G::from_u64(7);
+    let __v_23: G = (__v_20 * __v_20);
+    let __v_24: G = (__v_22 * __v_23);
+    let __v_25: G = (__v_21 - __v_24);
+    let __v_26: G = g_inverse_value(__v_25);
+    let __v_27: G = (__v_25 * __v_26);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = (__v_27 - __v_28);
+    let __v_30: G = (__v_25 * __v_29);
+    let __v_31: G = G::from_u64(0);
+    if (__v_30 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+    }
+    let __v_32: G = (__v_26 * __v_29);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    }
+    let __v_34: G = (__v_19 * __v_26);
+    let __v_35: G = G::from_u64(0);
+    let __v_36: G = (__v_35 - __v_20);
+    let __v_37: G = (__v_36 * __v_26);
+    let __v_38: G = (__v_17 * __v_34);
+    let __v_39: G = G::from_u64(7);
+    let __v_40: G = (__v_18 * __v_37);
+    let __v_41: G = (__v_39 * __v_40);
+    let __v_42: G = (__v_38 + __v_41);
+    let __v_43: G = (__v_17 * __v_37);
+    let __v_44: G = (__v_18 * __v_34);
+    let __v_45: G = (__v_43 + __v_44);
+    let __v_46: G = (__v_4 - __v_6);
+    let __v_47: G = (__v_5 - __v_7);
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = (__v_16 * __v_16);
+    let __v_50: G = G::from_u64(7);
+    let __v_51: G = (__v_48 * __v_48);
+    let __v_52: G = (__v_50 * __v_51);
+    let __v_53: G = (__v_49 - __v_52);
+    let __v_54: G = g_inverse_value(__v_53);
+    let __v_55: G = (__v_53 * __v_54);
+    let __v_56: G = G::from_u64(1);
+    let __v_57: G = (__v_55 - __v_56);
+    let __v_58: G = (__v_53 * __v_57);
+    let __v_59: G = G::from_u64(0);
+    if (__v_58 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
+    }
+    let __v_60: G = (__v_54 * __v_57);
+    let __v_61: G = G::from_u64(0);
+    if (__v_60 != __v_61) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+    }
+    let __v_62: G = (__v_16 * __v_54);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = (__v_63 - __v_48);
+    let __v_65: G = (__v_64 * __v_54);
+    let __v_66: G = (__v_46 * __v_62);
+    let __v_67: G = G::from_u64(7);
+    let __v_68: G = (__v_47 * __v_65);
+    let __v_69: G = (__v_67 * __v_68);
+    let __v_70: G = (__v_66 + __v_69);
+    let __v_71: G = (__v_46 * __v_65);
+    let __v_72: G = (__v_47 * __v_62);
+    let __v_73: G = (__v_71 + __v_72);
+    let __v_74: G = (__v_2 * __v_70);
+    let __v_75: G = G::from_u64(7);
+    let __v_76: G = (__v_3 * __v_73);
+    let __v_77: G = (__v_75 * __v_76);
+    let __v_78: G = (__v_74 + __v_77);
+    let __v_79: G = (__v_2 * __v_73);
+    let __v_80: G = (__v_3 * __v_70);
+    let __v_81: G = (__v_79 + __v_80);
+    let __v_82: G = (__v_42 + __v_78);
+    let __v_83: G = (__v_45 + __v_81);
+    let __ret: [G; OUT_120] = [__v_82, __v_83];
+    if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_121: usize = 2;
+const IN_121: usize = 2;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_121], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(7);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_1]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0, __v_6]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_7]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = (__v_2 * __v_8);
+    let __ret: [G; OUT_121] = [__v_9];
+    if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_122: usize = 8;
+const IN_122: usize = 8;
+const OUT_122: usize = 4;
+fn aiur_fn_122(
+  inp: [G; IN_122],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_122], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    let __v_15: G = __loaded[7];
+    let __v_16: G = __loaded[8];
+    let __v_17: G = __loaded[9];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_122] = [__v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_18: G = __loaded[0];
+        let __v_19: G = __loaded[1];
+        let __v_20: G = __loaded[2];
+        let __v_21: G = __loaded[3];
+        match __v_18.as_canonical_u64() {
+          0u64 => {
+            let __v_22: G = G::from_u64(256);
+            let __v_23: G = (__v_22 * __v_10);
+            let __v_24: G = G::from_u64(65536);
+            let __v_25: G = (__v_24 * __v_11);
+            let __v_26: G = G::from_u64(16777216);
+            let __v_27: G = (__v_26 * __v_12);
+            let __v_28: G = G::from_u64(4294967296);
+            let __v_29: G = (__v_28 * __v_13);
+            let __v_30: G = G::from_u64(1099511627776);
+            let __v_31: G = (__v_30 * __v_14);
+            let __v_32: G = G::from_u64(281474976710656);
+            let __v_33: G = (__v_32 * __v_15);
+            let __v_34: G = G::from_u64(72057594037927936);
+            let __v_35: G = (__v_34 * __v_16);
+            let __v_36: G = (__v_33 + __v_35);
+            let __v_37: G = (__v_31 + __v_36);
+            let __v_38: G = (__v_29 + __v_37);
+            let __v_39: G = (__v_27 + __v_38);
+            let __v_40: G = (__v_25 + __v_39);
+            let __v_41: G = (__v_23 + __v_40);
+            let __v_42: G = (__v_9 + __v_41);
+            let __v_43: G = G::from_u64(0);
+            let __v_44: G = (__v_19 - __v_42);
+            let __v_45: G = (__v_20 - __v_43);
+            let __v_46: G = (__v_6 * __v_44);
+            let __v_47: G = G::from_u64(7);
+            let __v_48: G = (__v_7 * __v_45);
+            let __v_49: G = (__v_47 * __v_48);
+            let __v_50: G = (__v_46 + __v_49);
+            let __v_51: G = (__v_6 * __v_45);
+            let __v_52: G = (__v_7 * __v_44);
+            let __v_53: G = (__v_51 + __v_52);
+            let __v_54: G = (__v_4 + __v_50);
+            let __v_55: G = (__v_5 + __v_53);
+            let __v_56: G = (__v_6 * __v_2);
+            let __v_57: G = G::from_u64(7);
+            let __v_58: G = (__v_7 * __v_3);
+            let __v_59: G = (__v_57 * __v_58);
+            let __v_60: G = (__v_56 + __v_59);
+            let __v_61: G = (__v_6 * __v_3);
+            let __v_62: G = (__v_7 * __v_2);
+            let __v_63: G = (__v_61 + __v_62);
+            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; 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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+            let __v_65: G = __r_arr[1];
+            let __v_66: G = __r_arr[2];
+            let __v_67: G = __r_arr[3];
+            let __ret: [G; OUT_122] = [__v_64, __v_65, __v_66, __v_67];
+            if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_123], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_123] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+        let __v_6: G = G::from_u8(__gb[0]);
+        let __v_7: G = G::from_u8(__gb[1]);
+        let __v_8: G = G::from_u8(__gb[2]);
+        let __v_9: G = G::from_u8(__gb[3]);
+        let __v_10: G = G::from_u8(__gb[4]);
+        let __v_11: G = G::from_u8(__gb[5]);
+        let __v_12: G = G::from_u8(__gb[6]);
+        let __v_13: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_14: G = G::from_u64(1020);
+        let __v_15: G = (__v_13 - __v_14);
+        let __v_16: G = (__v_12 + __v_15);
+        let __v_17: G = (__v_11 + __v_16);
+        let __v_18: G = (__v_10 + __v_17);
+        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+        let __v_20: G = (__v_8 + __v_9);
+        let __v_21: G = (__v_7 + __v_20);
+        let __v_22: G = (__v_6 + __v_21);
+        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
+        let __v_24: G = G::from_u8(__gb[0]);
+        let __v_25: G = G::from_u8(__gb[1]);
+        let __v_26: G = G::from_u8(__gb[2]);
+        let __v_27: G = G::from_u8(__gb[3]);
+        let __v_28: G = G::from_u8(__gb[4]);
+        let __v_29: G = G::from_u8(__gb[5]);
+        let __v_30: G = G::from_u8(__gb[6]);
+        let __v_31: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_32: G = G::from_u64(1020);
+        let __v_33: G = (__v_31 - __v_32);
+        let __v_34: G = (__v_30 + __v_33);
+        let __v_35: G = (__v_29 + __v_34);
+        let __v_36: G = (__v_28 + __v_35);
+        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
+        let __v_38: G = (__v_26 + __v_27);
+        let __v_39: G = (__v_25 + __v_38);
+        let __v_40: G = (__v_24 + __v_39);
+        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
+        let __v_42: G = G::from_u64(256);
+        let __v_43: G = (__v_42 * __v_7);
+        let __v_44: G = G::from_u64(65536);
+        let __v_45: G = (__v_44 * __v_8);
+        let __v_46: G = G::from_u64(16777216);
+        let __v_47: G = (__v_46 * __v_9);
+        let __v_48: G = G::from_u64(4294967296);
+        let __v_49: G = (__v_48 * __v_10);
+        let __v_50: G = G::from_u64(1099511627776);
+        let __v_51: G = (__v_50 * __v_11);
+        let __v_52: G = G::from_u64(281474976710656);
+        let __v_53: G = (__v_52 * __v_12);
+        let __v_54: G = G::from_u64(72057594037927936);
+        let __v_55: G = (__v_54 * __v_13);
+        let __v_56: G = (__v_53 + __v_55);
+        let __v_57: G = (__v_51 + __v_56);
+        let __v_58: G = (__v_49 + __v_57);
+        let __v_59: G = (__v_47 + __v_58);
+        let __v_60: G = (__v_45 + __v_59);
+        let __v_61: G = (__v_43 + __v_60);
+        let __v_62: G = (__v_6 + __v_61);
+        if (__v_62 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+        }
+        let __v_63: G = G::from_u64(1);
+        let __v_64: G = G::from_u64(1);
+        let __v_65: G = (__v_64 - __v_23);
+        let __v_66: G = (__v_19 * __v_65);
+        let __v_67: G = (__v_63 - __v_66);
+        let __v_68: G = G::from_u64(1);
+        if (__v_67 != __v_68) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
+        }
+        let __v_69: G = G::from_u64(256);
+        let __v_70: G = (__v_69 * __v_25);
+        let __v_71: G = G::from_u64(65536);
+        let __v_72: G = (__v_71 * __v_26);
+        let __v_73: G = G::from_u64(16777216);
+        let __v_74: G = (__v_73 * __v_27);
+        let __v_75: G = G::from_u64(4294967296);
+        let __v_76: G = (__v_75 * __v_28);
+        let __v_77: G = G::from_u64(1099511627776);
+        let __v_78: G = (__v_77 * __v_29);
+        let __v_79: G = G::from_u64(281474976710656);
+        let __v_80: G = (__v_79 * __v_30);
+        let __v_81: G = G::from_u64(72057594037927936);
+        let __v_82: G = (__v_81 * __v_31);
+        let __v_83: G = (__v_80 + __v_82);
+        let __v_84: G = (__v_78 + __v_83);
+        let __v_85: G = (__v_76 + __v_84);
+        let __v_86: G = (__v_74 + __v_85);
+        let __v_87: G = (__v_72 + __v_86);
+        let __v_88: G = (__v_70 + __v_87);
+        let __v_89: G = (__v_24 + __v_88);
+        if (__v_89 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+        }
+        let __v_90: G = G::from_u64(1);
+        let __v_91: G = G::from_u64(1);
+        let __v_92: G = (__v_91 - __v_41);
+        let __v_93: G = (__v_37 * __v_92);
+        let __v_94: G = (__v_90 - __v_93);
+        let __v_95: G = G::from_u64(1);
+        if (__v_94 != __v_95) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+        let __ret: [G; OUT_123] = [__v_98];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_124: usize = 2;
+const IN_124: usize = 2;
+const OUT_124: usize = 1;
+fn aiur_fn_124(
+  inp: [G; IN_124],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_124], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_124] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_4, __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 { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_5]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_124] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_125: usize = 2;
+const IN_125: usize = 2;
+const OUT_125: usize = 1;
+fn aiur_fn_125(
+  inp: [G; IN_125],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_125], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_125] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; 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 { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_125] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_126: usize = 3;
+const IN_126: usize = 3;
+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_126], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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_126] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_126] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_127: usize = 2;
+const IN_127: usize = 2;
+const OUT_127: usize = 1;
+fn aiur_fn_127(
+  inp: [G; IN_127],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_127], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_127] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_127] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_128: usize = 10;
+const IN_128: usize = 10;
+const OUT_128: usize = 2;
+fn aiur_fn_128(
+  inp: [G; IN_128],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_128], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    match __v_9.as_canonical_u64() {
+      0u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_128] = [__v_0, __v_12];
+        if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__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[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_10, __v_13, __v_9]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __v_16: G = __r_arr[2];
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(0);
+        if (__v_17 != __v_18) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        }
+        let __ret: [G; OUT_128] = [__v_15, __v_16];
+        if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_129: usize = 4;
+const IN_129: usize = 4;
+const OUT_129: usize = 2;
+fn aiur_fn_129(
+  inp: [G; IN_129],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_129], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_129] = [__v_9, __v_0];
+        if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_5]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_128] = { let __args: [G; IN_128] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_18, __v_19]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __v_28: G = __r_arr[8];
+            let __v_29: G = __r_arr[9];
+            let __v_30: G = __r_arr[10];
+            let __v_31: G = __r_arr[11];
+            let __v_32: G = __r_arr[12];
+            let __v_33: G = __r_arr[13];
+            let __v_34: G = __r_arr[14];
+            let __v_35: G = __r_arr[15];
+            let __v_36: G = __r_arr[16];
+            let __v_37: G = __r_arr[17];
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_36, __v_6, __v_16, __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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __v_40: G = G::from_u64(0);
+            let __v_41: G = G::from_u64(256);
+            let __v_42: G = (__v_41 * __v_21);
+            let __v_43: G = G::from_u64(65536);
+            let __v_44: G = (__v_43 * __v_22);
+            let __v_45: G = G::from_u64(16777216);
+            let __v_46: G = (__v_45 * __v_23);
+            let __v_47: G = G::from_u64(4294967296);
+            let __v_48: G = (__v_47 * __v_24);
+            let __v_49: G = G::from_u64(1099511627776);
+            let __v_50: G = (__v_49 * __v_25);
+            let __v_51: G = G::from_u64(281474976710656);
+            let __v_52: G = (__v_51 * __v_26);
+            let __v_53: G = G::from_u64(72057594037927936);
+            let __v_54: G = (__v_53 * __v_27);
+            let __v_55: G = (__v_52 + __v_54);
+            let __v_56: G = (__v_50 + __v_55);
+            let __v_57: G = (__v_48 + __v_56);
+            let __v_58: G = (__v_46 + __v_57);
+            let __v_59: G = (__v_44 + __v_58);
+            let __v_60: G = (__v_42 + __v_59);
+            let __v_61: G = (__v_20 + __v_60);
+            let __v_62: G = G::from_u64(256);
+            let __v_63: G = (__v_62 * __v_29);
+            let __v_64: G = G::from_u64(65536);
+            let __v_65: G = (__v_64 * __v_30);
+            let __v_66: G = G::from_u64(16777216);
+            let __v_67: G = (__v_66 * __v_31);
+            let __v_68: G = G::from_u64(4294967296);
+            let __v_69: G = (__v_68 * __v_32);
+            let __v_70: G = G::from_u64(1099511627776);
+            let __v_71: G = (__v_70 * __v_33);
+            let __v_72: G = G::from_u64(281474976710656);
+            let __v_73: G = (__v_72 * __v_34);
+            let __v_74: G = G::from_u64(72057594037927936);
+            let __v_75: G = (__v_74 * __v_35);
+            let __v_76: G = (__v_73 + __v_75);
+            let __v_77: G = (__v_71 + __v_76);
+            let __v_78: G = (__v_69 + __v_77);
+            let __v_79: G = (__v_67 + __v_78);
+            let __v_80: G = (__v_65 + __v_79);
+            let __v_81: G = (__v_63 + __v_80);
+            let __v_82: G = (__v_28 + __v_81);
+            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_129] = [__v_83, __v_39];
+            if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_130: usize = 5;
+const IN_130: usize = 5;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_130], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_130] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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 = (__v_1 - __v_4);
+        let __v_7: G = (__v_5 + __v_6);
+        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_130] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_2 - __v_9);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 + __v_11);
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __ret: [G; OUT_130] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_131: usize = 4;
+const IN_131: usize = 4;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_131], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_131] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_2, __v_4, __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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_3 - __v_6);
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_131] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 - __v_11);
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_12]; 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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_131] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_132: usize = 8;
+const IN_132: usize = 8;
+const OUT_132: usize = 1;
+fn aiur_fn_132(
+  inp: [G; IN_132],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_132], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __v_15: G = G::from_u64(1);
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_132] = [__v_17];
+        if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_9.as_canonical_u64() {
+          _ => {
+            let __v_15: G = (__v_9 - __v_1);
+            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+            match __v_16.as_canonical_u64() {
+              1u64 => {
+                let __v_17: G = G::from_u64(0);
+                let __v_18: G = G::from_u64(0);
+                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; 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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+                let __v_20: G = __r_arr[1];
+                let __v_21: G = __r_arr[2];
+                let __v_22: G = __r_arr[3];
+                let __v_23: G = (__v_4 * __v_19);
+                let __v_24: G = G::from_u64(7);
+                let __v_25: G = (__v_5 * __v_20);
+                let __v_26: G = (__v_24 * __v_25);
+                let __v_27: G = (__v_23 + __v_26);
+                let __v_28: G = (__v_4 * __v_20);
+                let __v_29: G = (__v_5 * __v_19);
+                let __v_30: G = (__v_28 + __v_29);
+                let __v_31: G = (__v_12 + __v_27);
+                let __v_32: G = (__v_13 + __v_30);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_132] = [__v_34];
+                if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_17: G = G::from_u64(0);
+                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_132] = [__v_19];
+                if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_133: usize = 2;
+const IN_133: usize = 2;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_133], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(1);
+        let __ret: [G; OUT_133] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_9: G = (__v_3 - __v_1);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = (__v_6 - __v_11);
+                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+                let __v_15: G = (__v_7 - __v_12);
+                let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+                let __v_17: G = (__v_14 * __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_17 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                let __v_19: G = G::from_u64(1);
+                let __ret: [G; OUT_133] = [__v_19];
+                if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_8, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_133] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_134], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_134] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_134] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_135: usize = 10;
+const IN_135: usize = 10;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_135], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = (__v_3 - __v_1);
+    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_10]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(7);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_1]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = G::from_u64(1);
+    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_11, __v_16]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13, __v_17]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+    let __v_19: G = (__v_12 * __v_18);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_4 - __v_19);
+    let __v_22: G = (__v_5 - __v_20);
+    let __v_23: G = (__v_21 * __v_21);
+    let __v_24: G = G::from_u64(7);
+    let __v_25: G = (__v_22 * __v_22);
+    let __v_26: G = (__v_24 * __v_25);
+    let __v_27: G = (__v_23 - __v_26);
+    let __v_28: G = g_inverse_value(__v_27);
+    let __v_29: G = (__v_27 * __v_28);
+    let __v_30: G = G::from_u64(1);
+    let __v_31: G = (__v_29 - __v_30);
+    let __v_32: G = (__v_27 * __v_31);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    }
+    let __v_34: G = (__v_28 * __v_31);
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
+    }
+    let __v_36: G = (__v_21 * __v_28);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = (__v_37 - __v_22);
+    let __v_39: G = (__v_38 * __v_28);
+    let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_6]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_40: 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = (__v_40 - __v_41);
+    let __v_43: G = G::from_bool((__v_42 == G::ZERO));
+    let __v_44: G = G::from_u64(1);
+    if (__v_43 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+    let __ret: [G; OUT_135] = [__v_45];
+    if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_136: usize = 11;
+const IN_136: usize = 11;
+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_136], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(1);
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_4]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = (__v_5 * __v_15);
+    let __v_18: G = G::from_u64(7);
+    let __v_19: G = (__v_6 * __v_16);
+    let __v_20: G = (__v_18 * __v_19);
+    let __v_21: G = (__v_17 + __v_20);
+    let __v_22: G = (__v_5 * __v_16);
+    let __v_23: G = (__v_6 * __v_15);
+    let __v_24: G = (__v_22 + __v_23);
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+    let __ret: [G; OUT_136] = [__v_26];
+    if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_137: usize = 13;
+const IN_137: usize = 13;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_137], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_137] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; 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 { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = (__v_4 + __v_18);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_5 - __v_20);
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __ret: [G; OUT_137] = [__v_22];
+        if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_138: usize = 13;
+const IN_138: usize = 13;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_138], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_138] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_16, __v_17]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_4 + __v_20);
+        let __v_22: G = G::from_u64(1);
+        let __v_23: G = (__v_5 - __v_22);
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_138] = [__v_24];
+        if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_139: usize = 15;
+const IN_139: usize = 15;
+const OUT_139: usize = 1;
+fn aiur_fn_139(
+  inp: [G; IN_139],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_139], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_139] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        match __v_15.as_canonical_u64() {
+          0u64 => {
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_4 + __v_17);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = (__v_5 - __v_19);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_21];
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_3);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; 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 { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = (__v_4 + __v_22);
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = (__v_5 - __v_24);
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_6 + __v_26);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_28];
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_140: usize = 15;
+const IN_140: usize = 15;
+const OUT_140: usize = 1;
+fn aiur_fn_140(
+  inp: [G; IN_140],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_140], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_140] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_15: G = G::from_u64(3);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        match __v_16.as_canonical_u64() {
+          _ => {
+            let __v_17: G = G::from_u64(0);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_6, __v_10, __v_5, __v_7, __v_17]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_142] = { let __args: [G; IN_142] = [__v_18]; 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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = (__v_20 - __v_21);
+            let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+            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: None });
+            }
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+            let __ret: [G; OUT_140] = [__v_27];
+            if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_141: usize = 4;
+const IN_141: usize = 4;
+const OUT_141: usize = 1;
+fn aiur_fn_141(
+  inp: [G; IN_141],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_141], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_141] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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 = (__v_5 + __v_1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 - __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 + __v_9);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_8, __v_10]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_141] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_142: usize = 1;
+const IN_142: usize = 1;
+const OUT_142: usize = 1;
+fn aiur_fn_142(
+  inp: [G; IN_142],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_142], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_142] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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 __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_142] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __ret: [G; OUT_142] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_143: usize = 5;
+const IN_143: usize = 5;
+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_143], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_143] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_3 - __v_7);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_4 + __v_9);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_2, __v_8, __v_10]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+            let __ret: [G; OUT_143] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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 = (__v_8 + __v_1);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_3 - __v_10);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_4 + __v_12);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_2, __v_11, __v_13]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_143] = [__v_15];
+            if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_144: usize = 5;
+const IN_144: usize = 5;
+const OUT_144: usize = 4;
+fn aiur_fn_144(
+  inp: [G; IN_144],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_144], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_144] = [__v_1, __v_2, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __ret: [G; OUT_144] = [__v_3, __v_4, __v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_145: usize = 4;
+const IN_145: usize = 4;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_145], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
+    let __v_4: G = G::from_u8(__gb[0]);
+    let __v_5: G = G::from_u8(__gb[1]);
+    let __v_6: G = G::from_u8(__gb[2]);
+    let __v_7: G = G::from_u8(__gb[3]);
+    let __v_8: G = G::from_u8(__gb[4]);
+    let __v_9: G = G::from_u8(__gb[5]);
+    let __v_10: G = G::from_u8(__gb[6]);
+    let __v_11: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_10 + __v_13);
+    let __v_15: G = (__v_9 + __v_14);
+    let __v_16: G = (__v_8 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_6 + __v_7);
+    let __v_19: G = (__v_5 + __v_18);
+    let __v_20: G = (__v_4 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes();
+    let __v_22: G = G::from_u8(__gb[0]);
+    let __v_23: G = G::from_u8(__gb[1]);
+    let __v_24: G = G::from_u8(__gb[2]);
+    let __v_25: G = G::from_u8(__gb[3]);
+    let __v_26: G = G::from_u8(__gb[4]);
+    let __v_27: G = G::from_u8(__gb[5]);
+    let __v_28: G = G::from_u8(__gb[6]);
+    let __v_29: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_22; let __vj = __v_23; 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_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_30: G = G::from_u64(1020);
+    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 __v_34: G = (__v_26 + __v_33);
+    let __v_35: G = G::from_bool((__v_34 == G::ZERO));
+    let __v_36: G = (__v_24 + __v_25);
+    let __v_37: G = (__v_23 + __v_36);
+    let __v_38: G = (__v_22 + __v_37);
+    let __v_39: G = G::from_bool((__v_38 == G::ZERO));
+    let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
+    let __v_40: G = G::from_u8(__gb[0]);
+    let __v_41: G = G::from_u8(__gb[1]);
+    let __v_42: G = G::from_u8(__gb[2]);
+    let __v_43: G = G::from_u8(__gb[3]);
+    let __v_44: G = G::from_u8(__gb[4]);
+    let __v_45: G = G::from_u8(__gb[5]);
+    let __v_46: G = G::from_u8(__gb[6]);
+    let __v_47: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_44; let __vj = __v_45; 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_46; let __vj = __v_47; 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_48: G = G::from_u64(1020);
+    let __v_49: G = (__v_47 - __v_48);
+    let __v_50: G = (__v_46 + __v_49);
+    let __v_51: G = (__v_45 + __v_50);
+    let __v_52: G = (__v_44 + __v_51);
+    let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+    let __v_54: G = (__v_42 + __v_43);
+    let __v_55: G = (__v_41 + __v_54);
+    let __v_56: G = (__v_40 + __v_55);
+    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+    let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+    let __v_58: G = G::from_u8(__gb[0]);
+    let __v_59: G = G::from_u8(__gb[1]);
+    let __v_60: G = G::from_u8(__gb[2]);
+    let __v_61: G = G::from_u8(__gb[3]);
+    let __v_62: G = G::from_u8(__gb[4]);
+    let __v_63: G = G::from_u8(__gb[5]);
+    let __v_64: G = G::from_u8(__gb[6]);
+    let __v_65: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66: G = G::from_u64(1020);
+    let __v_67: G = (__v_65 - __v_66);
+    let __v_68: G = (__v_64 + __v_67);
+    let __v_69: G = (__v_63 + __v_68);
+    let __v_70: G = (__v_62 + __v_69);
+    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+    let __v_72: G = (__v_60 + __v_61);
+    let __v_73: G = (__v_59 + __v_72);
+    let __v_74: G = (__v_58 + __v_73);
+    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(256);
+    let __v_78: G = (__v_77 * __v_5);
+    let __v_79: G = G::from_u64(65536);
+    let __v_80: G = (__v_79 * __v_6);
+    let __v_81: G = G::from_u64(16777216);
+    let __v_82: G = (__v_81 * __v_7);
+    let __v_83: G = G::from_u64(4294967296);
+    let __v_84: G = (__v_83 * __v_8);
+    let __v_85: G = G::from_u64(1099511627776);
+    let __v_86: G = (__v_85 * __v_9);
+    let __v_87: G = G::from_u64(281474976710656);
+    let __v_88: G = (__v_87 * __v_10);
+    let __v_89: G = G::from_u64(72057594037927936);
+    let __v_90: G = (__v_89 * __v_11);
+    let __v_91: G = (__v_88 + __v_90);
+    let __v_92: G = (__v_86 + __v_91);
+    let __v_93: G = (__v_84 + __v_92);
+    let __v_94: G = (__v_82 + __v_93);
+    let __v_95: G = (__v_80 + __v_94);
+    let __v_96: G = (__v_78 + __v_95);
+    let __v_97: G = (__v_4 + __v_96);
+    if (__v_97 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    let __v_98: G = G::from_u64(1);
+    let __v_99: G = G::from_u64(1);
+    let __v_100: G = (__v_99 - __v_21);
+    let __v_101: G = (__v_17 * __v_100);
+    let __v_102: G = (__v_98 - __v_101);
+    let __v_103: G = G::from_u64(1);
+    if (__v_102 != __v_103) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
+    }
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_23);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_24);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_25);
+    let __v_111: G = G::from_u64(4294967296);
+    let __v_112: G = (__v_111 * __v_26);
+    let __v_113: G = G::from_u64(1099511627776);
+    let __v_114: G = (__v_113 * __v_27);
+    let __v_115: G = G::from_u64(281474976710656);
+    let __v_116: G = (__v_115 * __v_28);
+    let __v_117: G = G::from_u64(72057594037927936);
+    let __v_118: G = (__v_117 * __v_29);
+    let __v_119: G = (__v_116 + __v_118);
+    let __v_120: G = (__v_114 + __v_119);
+    let __v_121: G = (__v_112 + __v_120);
+    let __v_122: G = (__v_110 + __v_121);
+    let __v_123: G = (__v_108 + __v_122);
+    let __v_124: G = (__v_106 + __v_123);
+    let __v_125: G = (__v_22 + __v_124);
+    if (__v_125 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    }
+    let __v_126: G = G::from_u64(1);
+    let __v_127: G = G::from_u64(1);
+    let __v_128: G = (__v_127 - __v_39);
+    let __v_129: G = (__v_35 * __v_128);
+    let __v_130: G = (__v_126 - __v_129);
+    let __v_131: G = G::from_u64(1);
+    if (__v_130 != __v_131) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+    }
+    let __v_132: G = G::from_u64(0);
+    let __v_133: G = G::from_u64(256);
+    let __v_134: G = (__v_133 * __v_41);
+    let __v_135: G = G::from_u64(65536);
+    let __v_136: G = (__v_135 * __v_42);
+    let __v_137: G = G::from_u64(16777216);
+    let __v_138: G = (__v_137 * __v_43);
+    let __v_139: G = G::from_u64(4294967296);
+    let __v_140: G = (__v_139 * __v_44);
+    let __v_141: G = G::from_u64(1099511627776);
+    let __v_142: G = (__v_141 * __v_45);
+    let __v_143: G = G::from_u64(281474976710656);
+    let __v_144: G = (__v_143 * __v_46);
+    let __v_145: G = G::from_u64(72057594037927936);
+    let __v_146: G = (__v_145 * __v_47);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_140 + __v_148);
+    let __v_150: G = (__v_138 + __v_149);
+    let __v_151: G = (__v_136 + __v_150);
+    let __v_152: G = (__v_134 + __v_151);
+    let __v_153: G = (__v_40 + __v_152);
+    if (__v_153 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    }
+    let __v_154: G = G::from_u64(1);
+    let __v_155: G = G::from_u64(1);
+    let __v_156: G = (__v_155 - __v_57);
+    let __v_157: G = (__v_53 * __v_156);
+    let __v_158: G = (__v_154 - __v_157);
+    let __v_159: G = G::from_u64(1);
+    if (__v_158 != __v_159) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
+    }
+    let __v_160: G = G::from_u64(0);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_59);
+    let __v_163: G = G::from_u64(65536);
+    let __v_164: G = (__v_163 * __v_60);
+    let __v_165: G = G::from_u64(16777216);
+    let __v_166: G = (__v_165 * __v_61);
+    let __v_167: G = G::from_u64(4294967296);
+    let __v_168: G = (__v_167 * __v_62);
+    let __v_169: G = G::from_u64(1099511627776);
+    let __v_170: G = (__v_169 * __v_63);
+    let __v_171: G = G::from_u64(281474976710656);
+    let __v_172: G = (__v_171 * __v_64);
+    let __v_173: G = G::from_u64(72057594037927936);
+    let __v_174: G = (__v_173 * __v_65);
+    let __v_175: G = (__v_172 + __v_174);
+    let __v_176: G = (__v_170 + __v_175);
+    let __v_177: G = (__v_168 + __v_176);
+    let __v_178: G = (__v_166 + __v_177);
+    let __v_179: G = (__v_164 + __v_178);
+    let __v_180: G = (__v_162 + __v_179);
+    let __v_181: G = (__v_58 + __v_180);
+    if (__v_181 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    }
+    let __v_182: G = G::from_u64(1);
+    let __v_183: G = G::from_u64(1);
+    let __v_184: G = (__v_183 - __v_75);
+    let __v_185: G = (__v_71 * __v_184);
+    let __v_186: G = (__v_182 - __v_185);
+    let __v_187: G = G::from_u64(1);
+    if (__v_186 != __v_187) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
+    }
+    let __v_188: G = G::from_u64(1);
+    let __v_189: G = G::from_u64(1);
+    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_145] = [__v_194];
+    if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_146: usize = 6;
+const IN_146: usize = 6;
+const OUT_146: usize = 3;
+fn aiur_fn_146(
+  inp: [G; IN_146],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_146], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    let __v_11: G = __loaded[5];
+    let __v_12: G = __loaded[6];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_146] = [__v_0, __v_1, __v_5];
+        if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __v_13: G = (__v_7 - __v_2);
+            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+            match __v_14.as_canonical_u64() {
+              1u64 => {
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_3, __v_4, __v_15]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                let __v_18: G = (__v_16 * __v_10);
+                let __v_19: G = G::from_u64(7);
+                let __v_20: G = (__v_17 * __v_11);
+                let __v_21: G = (__v_19 * __v_20);
+                let __v_22: G = (__v_18 + __v_21);
+                let __v_23: G = (__v_16 * __v_11);
+                let __v_24: G = (__v_17 * __v_10);
+                let __v_25: G = (__v_23 + __v_24);
+                let __v_26: G = (__v_0 + __v_22);
+                let __v_27: G = (__v_1 + __v_25);
+                let __ret: [G; OUT_146] = [__v_26, __v_27, __v_12];
+                if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __ret: [G; OUT_146] = [__v_0, __v_1, __v_5];
+                if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_147: usize = 9;
+const IN_147: usize = 9;
+const OUT_147: usize = 3;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_10: G = __loaded[1];
+    let __v_11: G = __loaded[2];
+    let __v_12: G = __loaded[3];
+    match __v_9.as_canonical_u64() {
+      1u64 => {
+        let __v_13: G = (__v_6 - __v_8);
+        let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+        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: None });
+        }
+        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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        if (__v_16 != __v_17) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
+        }
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_147] = [__v_0, __v_1, __v_20];
+        if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        match __v_13.as_canonical_u64() {
+          0u64 => {
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_17: G = __loaded[0];
+            let __v_18: G = __loaded[1];
+            let __v_19: G = __loaded[2];
+            match __v_17.as_canonical_u64() {
+              0u64 => {
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        let __v_23: G = G::from_u64(1);
+                        let __v_24: G = (__v_6 - __v_23);
+                        let __v_25: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_11, __v_25]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+                        let __v_27: G = __r_arr[1];
+                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_0, __v_1, __v_26, __v_27];
+  },
+  _ => {
+    break '__mc_0 [__v_26, __v_27, __v_0, __v_1];
+  },
+}
+ };
+                        let __v_28: G = __mc_out___mc_0[0];
+                        let __v_29: G = __mc_out___mc_0[1];
+                        let __v_30: G = __mc_out___mc_0[2];
+                        let __v_31: G = __mc_out___mc_0[3];
+                        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+                        let __v_33: G = __r_arr[1];
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+                        let __v_35: G = __r_arr[1];
+                        let __v_36: G = __r_arr[2];
+                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; 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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                        let __v_38: G = __r_arr[1];
+                        let __v_39: G = __r_arr[2];
+                        let __gb: [u8; 8] = __v_28.as_canonical_u64().to_le_bytes();
+                        let __v_40: G = G::from_u8(__gb[0]);
+                        let __v_41: G = G::from_u8(__gb[1]);
+                        let __v_42: G = G::from_u8(__gb[2]);
+                        let __v_43: G = G::from_u8(__gb[3]);
+                        let __v_44: G = G::from_u8(__gb[4]);
+                        let __v_45: G = G::from_u8(__gb[5]);
+                        let __v_46: G = G::from_u8(__gb[6]);
+                        let __v_47: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_44; let __vj = __v_45; 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_46; let __vj = __v_47; 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_48: G = G::from_u64(1020);
+                        let __v_49: G = (__v_47 - __v_48);
+                        let __v_50: G = (__v_46 + __v_49);
+                        let __v_51: G = (__v_45 + __v_50);
+                        let __v_52: G = (__v_44 + __v_51);
+                        let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+                        let __v_54: G = (__v_42 + __v_43);
+                        let __v_55: G = (__v_41 + __v_54);
+                        let __v_56: G = (__v_40 + __v_55);
+                        let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+                        let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
+                        let __v_58: G = G::from_u8(__gb[0]);
+                        let __v_59: G = G::from_u8(__gb[1]);
+                        let __v_60: G = G::from_u8(__gb[2]);
+                        let __v_61: G = G::from_u8(__gb[3]);
+                        let __v_62: G = G::from_u8(__gb[4]);
+                        let __v_63: G = G::from_u8(__gb[5]);
+                        let __v_64: G = G::from_u8(__gb[6]);
+                        let __v_65: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66: G = G::from_u64(1020);
+                        let __v_67: G = (__v_65 - __v_66);
+                        let __v_68: G = (__v_64 + __v_67);
+                        let __v_69: G = (__v_63 + __v_68);
+                        let __v_70: G = (__v_62 + __v_69);
+                        let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+                        let __v_72: G = (__v_60 + __v_61);
+                        let __v_73: G = (__v_59 + __v_72);
+                        let __v_74: G = (__v_58 + __v_73);
+                        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+                        let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
+                        let __v_76: G = G::from_u8(__gb[0]);
+                        let __v_77: G = G::from_u8(__gb[1]);
+                        let __v_78: G = G::from_u8(__gb[2]);
+                        let __v_79: G = G::from_u8(__gb[3]);
+                        let __v_80: G = G::from_u8(__gb[4]);
+                        let __v_81: G = G::from_u8(__gb[5]);
+                        let __v_82: G = G::from_u8(__gb[6]);
+                        let __v_83: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_76; let __vj = __v_77; 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_78; let __vj = __v_79; 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_80; let __vj = __v_81; 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_82; let __vj = __v_83; 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_84: G = G::from_u64(1020);
+                        let __v_85: G = (__v_83 - __v_84);
+                        let __v_86: G = (__v_82 + __v_85);
+                        let __v_87: G = (__v_81 + __v_86);
+                        let __v_88: G = (__v_80 + __v_87);
+                        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+                        let __v_90: G = (__v_78 + __v_79);
+                        let __v_91: G = (__v_77 + __v_90);
+                        let __v_92: G = (__v_76 + __v_91);
+                        let __v_93: G = G::from_bool((__v_92 == G::ZERO));
+                        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
+                        let __v_94: G = G::from_u8(__gb[0]);
+                        let __v_95: G = G::from_u8(__gb[1]);
+                        let __v_96: G = G::from_u8(__gb[2]);
+                        let __v_97: G = G::from_u8(__gb[3]);
+                        let __v_98: G = G::from_u8(__gb[4]);
+                        let __v_99: G = G::from_u8(__gb[5]);
+                        let __v_100: G = G::from_u8(__gb[6]);
+                        let __v_101: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_94; let __vj = __v_95; 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_96; let __vj = __v_97; 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_98; let __vj = __v_99; 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_100; let __vj = __v_101; 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_102: G = G::from_u64(1020);
+                        let __v_103: G = (__v_101 - __v_102);
+                        let __v_104: G = (__v_100 + __v_103);
+                        let __v_105: G = (__v_99 + __v_104);
+                        let __v_106: G = (__v_98 + __v_105);
+                        let __v_107: G = G::from_bool((__v_106 == G::ZERO));
+                        let __v_108: G = (__v_96 + __v_97);
+                        let __v_109: G = (__v_95 + __v_108);
+                        let __v_110: G = (__v_94 + __v_109);
+                        let __v_111: G = G::from_bool((__v_110 == G::ZERO));
+                        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+                        let __v_113: G = G::from_u64(1);
+                        if (__v_112 != __v_113) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_112.as_canonical_u64(), rhs: __v_113.as_canonical_u64(), msg: None });
+                        }
+                        let __v_114: G = G::from_u64(0);
+                        let __v_115: G = G::from_u64(0);
+                        let __v_116: G = G::from_u64(256);
+                        let __v_117: G = (__v_116 * __v_41);
+                        let __v_118: G = G::from_u64(65536);
+                        let __v_119: G = (__v_118 * __v_42);
+                        let __v_120: G = G::from_u64(16777216);
+                        let __v_121: G = (__v_120 * __v_43);
+                        let __v_122: G = G::from_u64(4294967296);
+                        let __v_123: G = (__v_122 * __v_44);
+                        let __v_124: G = G::from_u64(1099511627776);
+                        let __v_125: G = (__v_124 * __v_45);
+                        let __v_126: G = G::from_u64(281474976710656);
+                        let __v_127: G = (__v_126 * __v_46);
+                        let __v_128: G = G::from_u64(72057594037927936);
+                        let __v_129: G = (__v_128 * __v_47);
+                        let __v_130: G = (__v_127 + __v_129);
+                        let __v_131: G = (__v_125 + __v_130);
+                        let __v_132: G = (__v_123 + __v_131);
+                        let __v_133: G = (__v_121 + __v_132);
+                        let __v_134: G = (__v_119 + __v_133);
+                        let __v_135: G = (__v_117 + __v_134);
+                        let __v_136: G = (__v_40 + __v_135);
+                        if (__v_136 != __v_28) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
+                        }
+                        let __v_137: G = G::from_u64(1);
+                        let __v_138: G = G::from_u64(1);
+                        let __v_139: G = (__v_138 - __v_57);
+                        let __v_140: G = (__v_53 * __v_139);
+                        let __v_141: G = (__v_137 - __v_140);
+                        let __v_142: G = G::from_u64(1);
+                        if (__v_141 != __v_142) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_142.as_canonical_u64(), msg: None });
+                        }
+                        let __v_143: G = G::from_u64(0);
+                        let __v_144: G = G::from_u64(256);
+                        let __v_145: G = (__v_144 * __v_59);
+                        let __v_146: G = G::from_u64(65536);
+                        let __v_147: G = (__v_146 * __v_60);
+                        let __v_148: G = G::from_u64(16777216);
+                        let __v_149: G = (__v_148 * __v_61);
+                        let __v_150: G = G::from_u64(4294967296);
+                        let __v_151: G = (__v_150 * __v_62);
+                        let __v_152: G = G::from_u64(1099511627776);
+                        let __v_153: G = (__v_152 * __v_63);
+                        let __v_154: G = G::from_u64(281474976710656);
+                        let __v_155: G = (__v_154 * __v_64);
+                        let __v_156: G = G::from_u64(72057594037927936);
+                        let __v_157: G = (__v_156 * __v_65);
+                        let __v_158: G = (__v_155 + __v_157);
+                        let __v_159: G = (__v_153 + __v_158);
+                        let __v_160: G = (__v_151 + __v_159);
+                        let __v_161: G = (__v_149 + __v_160);
+                        let __v_162: G = (__v_147 + __v_161);
+                        let __v_163: G = (__v_145 + __v_162);
+                        let __v_164: G = (__v_58 + __v_163);
+                        if (__v_164 != __v_29) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                        }
+                        let __v_165: G = G::from_u64(1);
+                        let __v_166: G = G::from_u64(1);
+                        let __v_167: G = (__v_166 - __v_75);
+                        let __v_168: G = (__v_71 * __v_167);
+                        let __v_169: G = (__v_165 - __v_168);
+                        let __v_170: G = G::from_u64(1);
+                        if (__v_169 != __v_170) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: None });
+                        }
+                        let __v_171: G = G::from_u64(0);
+                        let __v_172: G = G::from_u64(256);
+                        let __v_173: G = (__v_172 * __v_77);
+                        let __v_174: G = G::from_u64(65536);
+                        let __v_175: G = (__v_174 * __v_78);
+                        let __v_176: G = G::from_u64(16777216);
+                        let __v_177: G = (__v_176 * __v_79);
+                        let __v_178: G = G::from_u64(4294967296);
+                        let __v_179: G = (__v_178 * __v_80);
+                        let __v_180: G = G::from_u64(1099511627776);
+                        let __v_181: G = (__v_180 * __v_81);
+                        let __v_182: G = G::from_u64(281474976710656);
+                        let __v_183: G = (__v_182 * __v_82);
+                        let __v_184: G = G::from_u64(72057594037927936);
+                        let __v_185: G = (__v_184 * __v_83);
+                        let __v_186: G = (__v_183 + __v_185);
+                        let __v_187: G = (__v_181 + __v_186);
+                        let __v_188: G = (__v_179 + __v_187);
+                        let __v_189: G = (__v_177 + __v_188);
+                        let __v_190: G = (__v_175 + __v_189);
+                        let __v_191: G = (__v_173 + __v_190);
+                        let __v_192: G = (__v_76 + __v_191);
+                        if (__v_192 != __v_30) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+                        }
+                        let __v_193: G = G::from_u64(1);
+                        let __v_194: G = G::from_u64(1);
+                        let __v_195: G = (__v_194 - __v_93);
+                        let __v_196: G = (__v_89 * __v_195);
+                        let __v_197: G = (__v_193 - __v_196);
+                        let __v_198: G = G::from_u64(1);
+                        if (__v_197 != __v_198) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_198.as_canonical_u64(), msg: None });
+                        }
+                        let __v_199: G = G::from_u64(0);
+                        let __v_200: G = G::from_u64(256);
+                        let __v_201: G = (__v_200 * __v_95);
+                        let __v_202: G = G::from_u64(65536);
+                        let __v_203: G = (__v_202 * __v_96);
+                        let __v_204: G = G::from_u64(16777216);
+                        let __v_205: G = (__v_204 * __v_97);
+                        let __v_206: G = G::from_u64(4294967296);
+                        let __v_207: G = (__v_206 * __v_98);
+                        let __v_208: G = G::from_u64(1099511627776);
+                        let __v_209: G = (__v_208 * __v_99);
+                        let __v_210: G = G::from_u64(281474976710656);
+                        let __v_211: G = (__v_210 * __v_100);
+                        let __v_212: G = G::from_u64(72057594037927936);
+                        let __v_213: G = (__v_212 * __v_101);
+                        let __v_214: G = (__v_211 + __v_213);
+                        let __v_215: G = (__v_209 + __v_214);
+                        let __v_216: G = (__v_207 + __v_215);
+                        let __v_217: G = (__v_205 + __v_216);
+                        let __v_218: G = (__v_203 + __v_217);
+                        let __v_219: G = (__v_201 + __v_218);
+                        let __v_220: G = (__v_94 + __v_219);
+                        if (__v_220 != __v_31) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+                        }
+                        let __v_221: G = G::from_u64(1);
+                        let __v_222: G = G::from_u64(1);
+                        let __v_223: G = (__v_222 - __v_111);
+                        let __v_224: G = (__v_107 * __v_223);
+                        let __v_225: G = (__v_221 - __v_224);
+                        let __v_226: G = G::from_u64(1);
+                        if (__v_225 != __v_226) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_226.as_canonical_u64(), msg: None });
+                        }
+                        let __v_227: G = G::from_u64(1);
+                        let __v_228: G = G::from_u64(1);
+                        let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_147] = [__v_37, __v_38, __v_234];
+                        if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_148: usize = 25;
+const IN_148: usize = 25;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_15, __v_19, __v_18, __v_20]; 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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_19, __v_18, __v_26]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_28]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        match __v_29.as_canonical_u64() {
+          _ => {
+            let __v_30: G = G::from_u64(0);
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+            let __v_32: G = G::from_u64(1);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_32]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+            match __v_33.as_canonical_u64() {
+              _ => {
+                let __v_34: G = G::from_u64(0);
+                let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+                let __v_36: G = G::from_u64(2);
+                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_36]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                match __v_37.as_canonical_u64() {
+                  _ => {
+                    let __v_38: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __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 { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+                    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; 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 { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_19]; 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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_41: G = __r_arr[0];
+                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+                    let __v_42: G = __loaded[0];
+                    let __v_43: G = __loaded[1];
+                    let __v_44: G = __loaded[2];
+                    let __v_45: G = __loaded[3];
+                    let __v_46: G = __loaded[4];
+                    let __v_47: G = __loaded[5];
+                    let __v_48: G = __loaded[6];
+                    match __v_42.as_canonical_u64() {
+                      0u64 => {
+                        match __v_43.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; 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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+                            let __v_50: G = __r_arr[1];
+                            let __v_51: G = __r_arr[2];
+                            let __v_52: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_52]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
+                            let __v_54: G = __r_arr[1];
+                            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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+                            let __v_56: G = (__v_55 - __v_24);
+                            let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+                            let __v_58: G = G::from_u64(1);
+                            if (__v_57 != __v_58) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+                            let __v_60: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_9]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+                            let __v_62: G = (__v_60 + __v_61);
+                            let __v_63: G = (__v_59 - __v_62);
+                            let __v_64: G = G::from_bool((__v_63 == G::ZERO));
+                            let __v_65: G = G::from_u64(1);
+                            if (__v_64 != __v_65) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_29]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_66: G = __r_arr[0];
+                            let __v_67: G = (__v_66 - __v_18);
+                            let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                            let __v_69: G = G::from_u64(1);
+                            if (__v_68 != __v_69) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_33]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
+                            let __v_71: G = (__v_70 - __v_18);
+                            let __v_72: G = G::from_bool((__v_71 == G::ZERO));
+                            let __v_73: G = G::from_u64(1);
+                            if (__v_72 != __v_73) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_74: G = __r_arr[0];
+                            let __v_75: G = (__v_74 - __v_18);
+                            let __v_76: G = G::from_bool((__v_75 == G::ZERO));
+                            let __v_77: G = G::from_u64(1);
+                            if (__v_76 != __v_77) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+                            }
+                            let __v_78: G = (__v_43 - __v_20);
+                            let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+                            let __v_80: G = G::from_u64(1);
+                            if (__v_79 != __v_80) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None });
+                            }
+                            let __v_81: G = (__v_53 - __v_49);
+                            let __v_82: G = G::from_bool((__v_81 == G::ZERO));
+                            let __v_83: G = (__v_54 - __v_50);
+                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
+                            let __v_85: G = (__v_82 * __v_84);
+                            let __v_86: G = G::from_u64(1);
+                            if (__v_85 != __v_86) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None });
+                            }
+                            let __ret: [G; OUT_148] = [__v_51];
+                            if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_149: usize = 25;
+const IN_149: usize = 25;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_26: G = __loaded[1];
+    let __v_27: G = __loaded[2];
+    let __v_28: G = __loaded[3];
+    match __v_25.as_canonical_u64() {
+      1u64 => {
+        let __v_29: G = G::from_u64(1);
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_149] = [__v_31];
+        if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_1, __v_20]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+        let __v_33: G = G::from_u64(0);
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_149] = [__v_35];
+        if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_150: usize = 4;
+const IN_150: usize = 4;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_150], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_150] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_1, __v_3]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = __r_arr[2];
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_2 - __v_8);
+        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_5, __v_6, __v_9, __v_3]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_150] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+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_151], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_151] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_1]; 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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_151] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_152: usize = 2;
+const IN_152: usize = 2;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_152], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_152] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_1]; 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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_152] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_153: usize = 4;
+const IN_153: usize = 4;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_153], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_153] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_2]; 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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 + __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 - __v_9);
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_8, __v_10]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_153] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_154: usize = 13;
+const IN_154: usize = 13;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_154], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = G::from_u64(0);
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_11, __v_10, __v_13]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(0);
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __v_18: G = G::from_u64(1);
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        match __v_19.as_canonical_u64() {
+          _ => {
+            let __v_21: G = G::from_u64(2);
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_21]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+            let __v_23: G = __r_arr[1];
+            match __v_22.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+                let __v_25: G = G::from_u64(1);
+                if (__v_24 != __v_25) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_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: None });
+                }
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+                let __v_29: G = G::from_u64(1);
+                if (__v_28 != __v_29) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                }
+                match __v_6.as_canonical_u64() {
+                  0u64 => {
+                    let __v_30: G = G::from_u64(1);
+                    let __ret: [G; OUT_154] = [__v_30];
+                    if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __v_30: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_30]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                    let __v_32: G = __r_arr[1];
+                    match __v_31.as_canonical_u64() {
+                      _ => {
+                        let __v_33: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_11, __v_8, __v_10, __v_33]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_34]; 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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+                        let __v_36: G = (__v_12 - __v_35);
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_1, __v_36]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+                        let __ret: [G; OUT_154] = [__v_38];
+                        if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_155], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_155] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_3, __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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_4, __v_1]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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];
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_155] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_156: usize = 2;
+const IN_156: usize = 2;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_156], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_156] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; 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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __v_13: G = { let __values: [G; 3] = [__v_5, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_156] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_157: usize = 6;
+const IN_157: usize = 6;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_157], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    match __v_6.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = G::from_bool((__v_11 == G::ZERO));
+        let __ret: [G; OUT_157] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_11: G = __loaded[0];
+        let __v_12: G = __loaded[1];
+        let __v_13: G = __loaded[2];
+        match __v_11.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              _ => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_3, __v_14]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = (__v_5 - __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_7 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+                let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+                if (__v_19 != __v_20) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_2, __v_4]; 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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+                let __v_22: G = G::from_u64(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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+                let __v_28: G = G::from_u64(1);
+                if (__v_27 != __v_28) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
+                }
+                let __v_29: G = G::from_u64(1);
+                let __v_30: G = (__v_4 + __v_29);
+                let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                let __ret: [G; OUT_157] = [__v_31];
+                if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_158: usize = 32;
+const IN_158: usize = 32;
+const OUT_158: usize = 1;
+fn aiur_fn_158(
+  inp: [G; IN_158],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_158], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    match __v_6.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+        let __v_33: G = G::from_u64(1);
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_35];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_35]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+    break '__mc_0 [__v_36];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+  },
+}
+ };
+        let __v_36: G = __mc_out___mc_0[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_36]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_37]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_38]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_39]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_40: G = __r_arr[0];
+        let __v_41: G = G::from_u64(1);
+        let __v_42: G = G::from_u64(1);
+        let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_40, __v_43]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        let __v_53: G = __r_arr[9];
+        let __v_54: G = __r_arr[10];
+        let __v_55: G = __r_arr[11];
+        let __v_56: G = __r_arr[12];
+        let __v_57: G = __r_arr[13];
+        let __v_58: G = __r_arr[14];
+        let __v_59: G = __r_arr[15];
+        let __v_60: G = __r_arr[16];
+        let __v_61: G = __r_arr[17];
+        let __v_62: G = G::from_u64(256);
+        let __v_63: G = (__v_62 * __v_45);
+        let __v_64: G = G::from_u64(65536);
+        let __v_65: G = (__v_64 * __v_46);
+        let __v_66: G = G::from_u64(16777216);
+        let __v_67: G = (__v_66 * __v_47);
+        let __v_68: G = G::from_u64(4294967296);
+        let __v_69: G = (__v_68 * __v_48);
+        let __v_70: G = G::from_u64(1099511627776);
+        let __v_71: G = (__v_70 * __v_49);
+        let __v_72: G = G::from_u64(281474976710656);
+        let __v_73: G = (__v_72 * __v_50);
+        let __v_74: G = G::from_u64(72057594037927936);
+        let __v_75: G = (__v_74 * __v_51);
+        let __v_76: G = (__v_73 + __v_75);
+        let __v_77: G = (__v_71 + __v_76);
+        let __v_78: G = (__v_69 + __v_77);
+        let __v_79: G = (__v_67 + __v_78);
+        let __v_80: G = (__v_65 + __v_79);
+        let __v_81: G = (__v_63 + __v_80);
+        let __v_82: G = (__v_44 + __v_81);
+        let __v_83: G = G::from_u64(256);
+        let __v_84: G = (__v_83 * __v_53);
+        let __v_85: G = G::from_u64(65536);
+        let __v_86: G = (__v_85 * __v_54);
+        let __v_87: G = G::from_u64(16777216);
+        let __v_88: G = (__v_87 * __v_55);
+        let __v_89: G = G::from_u64(4294967296);
+        let __v_90: G = (__v_89 * __v_56);
+        let __v_91: G = G::from_u64(1099511627776);
+        let __v_92: G = (__v_91 * __v_57);
+        let __v_93: G = G::from_u64(281474976710656);
+        let __v_94: G = (__v_93 * __v_58);
+        let __v_95: G = G::from_u64(72057594037927936);
+        let __v_96: G = (__v_95 * __v_59);
+        let __v_97: G = (__v_94 + __v_96);
+        let __v_98: G = (__v_92 + __v_97);
+        let __v_99: G = (__v_90 + __v_98);
+        let __v_100: G = (__v_88 + __v_99);
+        let __v_101: G = (__v_86 + __v_100);
+        let __v_102: G = (__v_84 + __v_101);
+        let __v_103: G = (__v_52 + __v_102);
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_60, __v_6, __v_7, __v_30]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
+        let __v_106: G = G::from_u64(1);
+        let __v_107: G = G::from_u64(1);
+        let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10, __v_108]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_109: G = __r_arr[0];
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_105, __v_109]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_110: G = __r_arr[0];
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_110, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_111: G = __r_arr[0];
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+        let __v_113: G = __r_arr[1];
+        let __v_114: G = (__v_32 + __v_28);
+        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_29, __v_114]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_115: G = __r_arr[0];
+        let __v_116: G = G::from_u64(0);
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_8, __v_9, __v_116, __v_29]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_117: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+        let __v_120: G = (__v_119 - __v_32);
+        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
+        let __v_122: G = G::from_u64(1);
+        if (__v_121 != __v_122) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None });
+        }
+        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+        let __v_124: G = G::from_u64(3);
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_5]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_125: G = __r_arr[0];
+        let __v_126: G = (__v_124 + __v_125);
+        if (__v_123 != __v_126) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_127: G = __r_arr[0];
+        let __v_128: G = (__v_127 - __v_32);
+        let __v_129: G = G::from_bool((__v_128 == G::ZERO));
+        let __v_130: G = G::from_u64(1);
+        if (__v_129 != __v_130) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None });
+        }
+        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_131: G = __r_arr[0];
+        let __v_132: G = G::from_u64(1);
+        if (__v_131 != __v_132) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None });
+        }
+        let __v_133: G = G::from_u64(33);
+        let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        let __v_135: G = G::from_u64(1);
+        if (__v_134 != __v_135) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_136: G = __r_arr[0];
+        let __v_137: G = G::from_u64(1);
+        if (__v_136 != __v_137) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None });
+        }
+        let __v_138: G = G::from_u64(0);
+        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_139: G = __r_arr[0];
+        let __ret: [G; OUT_158] = [__v_139];
+        if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_159: usize = 2;
+const IN_159: usize = 2;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_159], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_bool((__v_0 == G::ZERO));
+    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
+    let __v_4: G = (__v_2 * __v_3);
+    let __ret: [G; OUT_159] = [__v_4];
+    if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_160: usize = 1;
+const IN_160: usize = 1;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_160], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_160] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_bool((__v_2 == G::ZERO));
+            let __v_10: G = G::from_bool((__v_3 == G::ZERO));
+            let __v_11: G = (__v_9 * __v_10);
+            let __ret: [G; OUT_160] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __ret: [G; OUT_160] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_161: usize = 9;
+const IN_161: usize = 9;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_161], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_161] = [__v_24];
+    if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_162: usize = 33;
+const IN_162: usize = 33;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_162], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+    let __ret: [G; OUT_162] = [__v_36];
+    if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_163: usize = 2;
+const IN_163: usize = 2;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_163], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_163] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        let __v_15: G = __loaded[10];
+        let __v_16: G = __loaded[11];
+        let __v_17: G = __loaded[12];
+        let __v_18: G = __loaded[13];
+        let __v_19: G = __loaded[14];
+        let __v_20: G = __loaded[15];
+        let __v_21: G = __loaded[16];
+        let __v_22: G = __loaded[17];
+        let __v_23: G = __loaded[18];
+        let __v_24: G = __loaded[19];
+        let __v_25: G = __loaded[20];
+        let __v_26: G = __loaded[21];
+        let __v_27: G = __loaded[22];
+        let __v_28: G = __loaded[23];
+        let __v_29: G = __loaded[24];
+        let __v_30: G = __loaded[25];
+        let __v_31: G = __loaded[26];
+        let __v_32: G = __loaded[27];
+        let __v_33: G = __loaded[28];
+        let __v_34: G = __loaded[29];
+        let __v_35: G = __loaded[30];
+        let __v_36: G = __loaded[31];
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+        let __ret: [G; OUT_163] = [__v_41];
+        if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_164: usize = 2;
+const IN_164: usize = 2;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_164], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_164] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __ret: [G; OUT_164] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_165: usize = 2;
+const IN_165: usize = 2;
+const OUT_165: usize = 10;
+fn aiur_fn_165(
+  inp: [G; IN_165],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_165], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(103);
+        let __v_6: G = G::from_u64(230);
+        let __v_7: G = G::from_u64(9);
+        let __v_8: G = G::from_u64(106);
+        let __v_9: G = G::from_u64(133);
+        let __v_10: G = G::from_u64(174);
+        let __v_11: G = G::from_u64(103);
+        let __v_12: G = G::from_u64(187);
+        let __v_13: G = G::from_u64(114);
+        let __v_14: G = G::from_u64(243);
+        let __v_15: G = G::from_u64(110);
+        let __v_16: G = G::from_u64(60);
+        let __v_17: G = G::from_u64(58);
+        let __v_18: G = G::from_u64(245);
+        let __v_19: G = G::from_u64(79);
+        let __v_20: G = G::from_u64(165);
+        let __v_21: G = G::from_u64(127);
+        let __v_22: G = G::from_u64(82);
+        let __v_23: G = G::from_u64(14);
+        let __v_24: G = G::from_u64(81);
+        let __v_25: G = G::from_u64(140);
+        let __v_26: G = G::from_u64(104);
+        let __v_27: G = G::from_u64(5);
+        let __v_28: G = G::from_u64(155);
+        let __v_29: G = G::from_u64(171);
+        let __v_30: G = G::from_u64(217);
+        let __v_31: G = G::from_u64(131);
+        let __v_32: G = G::from_u64(31);
+        let __v_33: G = G::from_u64(25);
+        let __v_34: G = G::from_u64(205);
+        let __v_35: G = G::from_u64(224);
+        let __v_36: G = G::from_u64(91);
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_40: G = G::from_u64(0);
+        let __v_41: G = G::from_u64(0);
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = G::from_u64(0);
+        let __v_44: G = G::from_u64(0);
+        let __v_45: G = G::from_u64(0);
+        let __v_46: G = G::from_u64(0);
+        let __v_47: G = G::from_u64(0);
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = G::from_u64(0);
+        let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = G::from_u64(1);
+        let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
+        let __v_57: G = __r_arr[1];
+        let __v_58: G = __r_arr[2];
+        let __v_59: G = __r_arr[3];
+        let __v_60: G = __r_arr[4];
+        let __v_61: G = __r_arr[5];
+        let __v_62: G = __r_arr[6];
+        let __v_63: G = __r_arr[7];
+        let __v_64: G = __r_arr[8];
+        let __v_65: G = __r_arr[9];
+        let __v_66: G = __r_arr[10];
+        let __v_67: G = __r_arr[11];
+        let __v_68: G = __r_arr[12];
+        let __v_69: G = __r_arr[13];
+        let __v_70: G = __r_arr[14];
+        let __v_71: G = __r_arr[15];
+        let __v_72: G = __r_arr[16];
+        let __v_73: G = __r_arr[17];
+        let __v_74: G = __r_arr[18];
+        let __v_75: G = __r_arr[19];
+        let __v_76: G = __r_arr[20];
+        let __v_77: G = __r_arr[21];
+        let __v_78: G = __r_arr[22];
+        let __v_79: G = __r_arr[23];
+        let __v_80: G = __r_arr[24];
+        let __v_81: G = __r_arr[25];
+        let __v_82: G = __r_arr[26];
+        let __v_83: G = __r_arr[27];
+        let __v_84: G = __r_arr[28];
+        let __v_85: G = __r_arr[29];
+        let __v_86: G = __r_arr[30];
+        let __v_87: G = __r_arr[31];
+        let __v_88: G = G::from_u64(1);
+        let __v_89: G = G::from_u64(1);
+        let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_91: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_92: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_93: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_94: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_95: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_98: G = __r_arr[0];
+        let __v_99: G = G::from_u64(1);
+        let __v_100: G = G::from_u64(1);
+        let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_98, __v_101]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_102: 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_102.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        match __v_103.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_106: G = __loaded[0];
+            let __v_107: G = __loaded[1];
+            let __v_108: G = __loaded[2];
+            match __v_106.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_109: G = __loaded[0];
+                let __v_110: G = __loaded[1];
+                let __v_111: G = __loaded[2];
+                match __v_109.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_112: G = __loaded[0];
+                    let __v_113: G = __loaded[1];
+                    let __v_114: G = __loaded[2];
+                    match __v_112.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_115: G = __loaded[0];
+                        let __v_116: G = __loaded[1];
+                        let __v_117: G = __loaded[2];
+                        match __v_115.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_118: G = __loaded[0];
+                            let __v_119: G = __loaded[1];
+                            let __v_120: G = __loaded[2];
+                            match __v_118.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_121: G = __loaded[0];
+                                let __v_122: G = __loaded[1];
+                                let __v_123: G = __loaded[2];
+                                match __v_121.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_124: G = __loaded[0];
+                                    let __v_125: G = __loaded[1];
+                                    let __v_126: G = __loaded[2];
+                                    match __v_124.as_canonical_u64() {
+                                      0u64 => {
+                                        let __ret: [G; OUT_165] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
+                                        if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_14: G = __loaded[0];
+                    let __v_15: G = __loaded[1];
+                    let __v_16: G = __loaded[2];
+                    match __v_14.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_17: G = __loaded[0];
+                        let __v_18: G = __loaded[1];
+                        let __v_19: G = __loaded[2];
+                        match __v_17.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                            let __v_21: G = __loaded[1];
+                            let __v_22: G = __loaded[2];
+                            match __v_20.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_23: G = __loaded[0];
+                                let __v_24: G = __loaded[1];
+                                let __v_25: G = __loaded[2];
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    let __ret: [G; OUT_165] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
+                                    if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_166: usize = 2;
+const IN_166: usize = 2;
+const OUT_166: usize = 10;
+fn aiur_fn_166(
+  inp: [G; IN_166],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_166], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1]; 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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_9 - __v_12);
+    let __v_14: G = (__v_8 + __v_13);
+    let __v_15: G = (__v_7 + __v_14);
+    let __v_16: G = (__v_6 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_4 + __v_5);
+    let __v_19: G = (__v_3 + __v_18);
+    let __v_20: G = (__v_2 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = (__v_23 - __v_21);
+    let __v_25: G = (__v_17 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    match __v_26.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_166] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_11]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __ret: [G; OUT_166] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_167: usize = 2;
+const IN_167: usize = 2;
+const OUT_167: usize = 18;
+fn aiur_fn_167(
+  inp: [G; IN_167],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_167], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_11]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __v_14: G = __r_arr[2];
+    let __v_15: G = __r_arr[3];
+    let __v_16: G = __r_arr[4];
+    let __v_17: G = __r_arr[5];
+    let __v_18: G = __r_arr[6];
+    let __v_19: G = __r_arr[7];
+    let __v_20: G = __r_arr[8];
+    let __v_21: G = __r_arr[9];
+    let __ret: [G; OUT_167] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    if !unconstrained { record.virt += record.function_queries[167].weight(); } record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_168: usize = 2;
+const IN_168: usize = 2;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_168], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_168] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_7]; 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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_168] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_169: usize = 3;
+const IN_169: usize = 3;
+const OUT_169: usize = 3;
+fn aiur_fn_169(
+  inp: [G; IN_169],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_169], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1]; 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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __v_11: G = __r_arr[8];
+    let __v_12: G = __r_arr[9];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) };
+    let __v_13: G = __b1_out[0];
+    let __v_14: G = __b1_out[1];
+    let __v_15: G = __b1_out[2];
+    let __v_16: G = __b1_out[3];
+    let __v_17: G = __b1_out[4];
+    let __v_18: G = __b1_out[5];
+    let __v_19: G = __b1_out[6];
+    let __v_20: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) };
+    let __v_21: G = __b1_out[0];
+    let __v_22: G = __b1_out[1];
+    let __v_23: G = __b1_out[2];
+    let __v_24: G = __b1_out[3];
+    let __v_25: G = __b1_out[4];
+    let __v_26: G = __b1_out[5];
+    let __v_27: G = __b1_out[6];
+    let __v_28: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
+    let __v_29: G = __b1_out[0];
+    let __v_30: G = __b1_out[1];
+    let __v_31: G = __b1_out[2];
+    let __v_32: G = __b1_out[3];
+    let __v_33: G = __b1_out[4];
+    let __v_34: G = __b1_out[5];
+    let __v_35: G = __b1_out[6];
+    let __v_36: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
+    let __v_37: G = __b1_out[0];
+    let __v_38: G = __b1_out[1];
+    let __v_39: G = __b1_out[2];
+    let __v_40: G = __b1_out[3];
+    let __v_41: G = __b1_out[4];
+    let __v_42: G = __b1_out[5];
+    let __v_43: G = __b1_out[6];
+    let __v_44: G = __b1_out[7];
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_51, __v_2]; 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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+    let __ret: [G; OUT_169] = [__v_52, __v_11, __v_12];
+    if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_170: usize = 9;
+const IN_170: usize = 9;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_170], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_12]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
+    let __ret: [G; OUT_170] = [__v_13];
+    if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_171: usize = 2;
+const IN_171: usize = 2;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_171], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_4]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_5]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
+    let __ret: [G; OUT_171] = [__v_6];
+    if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_172: usize = 1;
+const IN_172: usize = 1;
+const OUT_172: usize = 1;
+fn aiur_fn_172(
+  inp: [G; IN_172],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_172], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(109);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(117);
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(116);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(105);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(45);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(115);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(116);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(97);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(114);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(107);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(47);
+    let __v_25: G = G::from_u64(0);
+    let __v_26: G = G::from_u64(118);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(48);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_172] = [__v_42];
+    if !unconstrained { record.virt += record.function_queries[172].weight(); } record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_173: usize = 2;
+const IN_173: usize = 2;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_173], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_173] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_11, __v_1]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __ret: [G; OUT_173] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_174: usize = 2;
+const IN_174: usize = 2;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_174], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_174] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __ret: [G; OUT_174] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_175: usize = 9;
+const IN_175: usize = 9;
+const OUT_175: usize = 9;
+fn aiur_fn_175(
+  inp: [G; IN_175],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_175], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_6, __v_7]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_9]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_2, __v_10]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_11]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_12]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(109);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(117);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(108);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(116);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(105);
+    let __v_24: G = G::from_u64(0);
+    let __v_25: G = G::from_u64(45);
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(115);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(116);
+    let __v_30: G = G::from_u64(0);
+    let __v_31: G = G::from_u64(97);
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(114);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(107);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(47);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(118);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(48);
+    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_56: G = G::from_u64(1);
+    let __v_57: G = G::from_u64(1);
+    let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_55, __v_58]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __v_62: G = __r_arr[3];
+    let __v_63: G = __r_arr[4];
+    let __v_64: G = __r_arr[5];
+    let __v_65: G = __r_arr[6];
+    let __v_66: G = __r_arr[7];
+    let __v_67: G = __r_arr[8];
+    let __v_68: G = __r_arr[9];
+    let __v_69: G = __r_arr[10];
+    let __v_70: G = __r_arr[11];
+    let __v_71: G = __r_arr[12];
+    let __v_72: G = __r_arr[13];
+    let __v_73: G = __r_arr[14];
+    let __v_74: G = __r_arr[15];
+    let __v_75: G = __r_arr[16];
+    let __v_76: G = __r_arr[17];
+    let __v_77: G = G::from_u64(1);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_75, __v_81]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_82: G = __r_arr[0];
+    let __v_83: G = G::from_u64(1);
+    let __v_84: G = G::from_u64(1);
+    let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_82, __v_85]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_86: G = __r_arr[0];
+    let __v_87: G = __r_arr[1];
+    let __v_88: G = __r_arr[2];
+    let __v_89: G = __r_arr[3];
+    let __v_90: G = __r_arr[4];
+    let __v_91: G = __r_arr[5];
+    let __v_92: G = __r_arr[6];
+    let __v_93: G = __r_arr[7];
+    let __v_94: G = __r_arr[8];
+    let __v_95: G = __r_arr[9];
+    let __v_96: G = __r_arr[10];
+    let __v_97: G = __r_arr[11];
+    let __v_98: G = __r_arr[12];
+    let __v_99: G = __r_arr[13];
+    let __v_100: G = __r_arr[14];
+    let __v_101: G = __r_arr[15];
+    let __v_102: G = __r_arr[16];
+    let __v_103: G = __r_arr[17];
+    let __v_104: G = G::from_u64(1);
+    let __v_105: G = G::from_u64(1);
+    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_107: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_108: G = __r_arr[0];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_102, __v_108]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_109: G = __r_arr[0];
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_109, __v_4]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_110: G = __r_arr[0];
+    let __v_111: G = G::from_u64(1);
+    let __v_112: G = G::from_u64(1);
+    let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_8, __v_113]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_114: G = __r_arr[0];
+    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_110, __v_114]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_115: G = __r_arr[0];
+    let __v_116: G = G::from_u64(1);
+    let __v_117: G = G::from_u64(1);
+    let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_115, __v_118]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __v_121: G = __r_arr[2];
+    let __v_122: G = __r_arr[3];
+    let __v_123: G = __r_arr[4];
+    let __v_124: G = __r_arr[5];
+    let __v_125: G = __r_arr[6];
+    let __v_126: G = __r_arr[7];
+    let __v_127: G = __r_arr[8];
+    let __v_128: G = __r_arr[9];
+    let __v_129: G = __r_arr[10];
+    let __v_130: G = __r_arr[11];
+    let __v_131: G = __r_arr[12];
+    let __v_132: G = __r_arr[13];
+    let __v_133: G = __r_arr[14];
+    let __v_134: G = __r_arr[15];
+    let __v_135: G = __r_arr[16];
+    let __v_136: G = __r_arr[17];
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_135, __v_5]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_137: G = __r_arr[0];
+    let __v_138: G = G::from_u64(1);
+    let __v_139: G = G::from_u64(1);
+    let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_137, __v_140]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __v_143: G = __r_arr[2];
+    let __v_144: G = __r_arr[3];
+    let __v_145: G = __r_arr[4];
+    let __v_146: G = __r_arr[5];
+    let __v_147: G = __r_arr[6];
+    let __v_148: G = __r_arr[7];
+    let __v_149: G = __r_arr[8];
+    let __v_150: G = __r_arr[9];
+    let __v_151: G = __r_arr[10];
+    let __v_152: G = __r_arr[11];
+    let __v_153: G = __r_arr[12];
+    let __v_154: G = __r_arr[13];
+    let __v_155: G = __r_arr[14];
+    let __v_156: G = __r_arr[15];
+    let __v_157: G = __r_arr[16];
+    let __v_158: G = __r_arr[17];
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_60);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_61);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_62);
+    let __v_165: G = G::from_u64(4294967296);
+    let __v_166: G = (__v_165 * __v_63);
+    let __v_167: G = G::from_u64(1099511627776);
+    let __v_168: G = (__v_167 * __v_64);
+    let __v_169: G = G::from_u64(281474976710656);
+    let __v_170: G = (__v_169 * __v_65);
+    let __v_171: G = G::from_u64(72057594037927936);
+    let __v_172: G = (__v_171 * __v_66);
+    let __v_173: G = (__v_170 + __v_172);
+    let __v_174: G = (__v_168 + __v_173);
+    let __v_175: G = (__v_166 + __v_174);
+    let __v_176: G = (__v_164 + __v_175);
+    let __v_177: G = (__v_162 + __v_176);
+    let __v_178: G = (__v_160 + __v_177);
+    let __v_179: G = (__v_59 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_68);
+    let __v_182: G = G::from_u64(65536);
+    let __v_183: G = (__v_182 * __v_69);
+    let __v_184: G = G::from_u64(16777216);
+    let __v_185: G = (__v_184 * __v_70);
+    let __v_186: G = G::from_u64(4294967296);
+    let __v_187: G = (__v_186 * __v_71);
+    let __v_188: G = G::from_u64(1099511627776);
+    let __v_189: G = (__v_188 * __v_72);
+    let __v_190: G = G::from_u64(281474976710656);
+    let __v_191: G = (__v_190 * __v_73);
+    let __v_192: G = G::from_u64(72057594037927936);
+    let __v_193: G = (__v_192 * __v_74);
+    let __v_194: G = (__v_191 + __v_193);
+    let __v_195: G = (__v_189 + __v_194);
+    let __v_196: G = (__v_187 + __v_195);
+    let __v_197: G = (__v_185 + __v_196);
+    let __v_198: G = (__v_183 + __v_197);
+    let __v_199: G = (__v_181 + __v_198);
+    let __v_200: G = (__v_67 + __v_199);
+    let __v_201: G = G::from_u64(256);
+    let __v_202: G = (__v_201 * __v_87);
+    let __v_203: G = G::from_u64(65536);
+    let __v_204: G = (__v_203 * __v_88);
+    let __v_205: G = G::from_u64(16777216);
+    let __v_206: G = (__v_205 * __v_89);
+    let __v_207: G = G::from_u64(4294967296);
+    let __v_208: G = (__v_207 * __v_90);
+    let __v_209: G = G::from_u64(1099511627776);
+    let __v_210: G = (__v_209 * __v_91);
+    let __v_211: G = G::from_u64(281474976710656);
+    let __v_212: G = (__v_211 * __v_92);
+    let __v_213: G = G::from_u64(72057594037927936);
+    let __v_214: G = (__v_213 * __v_93);
+    let __v_215: G = (__v_212 + __v_214);
+    let __v_216: G = (__v_210 + __v_215);
+    let __v_217: G = (__v_208 + __v_216);
+    let __v_218: G = (__v_206 + __v_217);
+    let __v_219: G = (__v_204 + __v_218);
+    let __v_220: G = (__v_202 + __v_219);
+    let __v_221: G = (__v_86 + __v_220);
+    let __v_222: G = G::from_u64(256);
+    let __v_223: G = (__v_222 * __v_95);
+    let __v_224: G = G::from_u64(65536);
+    let __v_225: G = (__v_224 * __v_96);
+    let __v_226: G = G::from_u64(16777216);
+    let __v_227: G = (__v_226 * __v_97);
+    let __v_228: G = G::from_u64(4294967296);
+    let __v_229: G = (__v_228 * __v_98);
+    let __v_230: G = G::from_u64(1099511627776);
+    let __v_231: G = (__v_230 * __v_99);
+    let __v_232: G = G::from_u64(281474976710656);
+    let __v_233: G = (__v_232 * __v_100);
+    let __v_234: G = G::from_u64(72057594037927936);
+    let __v_235: G = (__v_234 * __v_101);
+    let __v_236: G = (__v_233 + __v_235);
+    let __v_237: G = (__v_231 + __v_236);
+    let __v_238: G = (__v_229 + __v_237);
+    let __v_239: G = (__v_227 + __v_238);
+    let __v_240: G = (__v_225 + __v_239);
+    let __v_241: G = (__v_223 + __v_240);
+    let __v_242: G = (__v_94 + __v_241);
+    let __v_243: G = G::from_u64(256);
+    let __v_244: G = (__v_243 * __v_120);
+    let __v_245: G = G::from_u64(65536);
+    let __v_246: G = (__v_245 * __v_121);
+    let __v_247: G = G::from_u64(16777216);
+    let __v_248: G = (__v_247 * __v_122);
+    let __v_249: G = G::from_u64(4294967296);
+    let __v_250: G = (__v_249 * __v_123);
+    let __v_251: G = G::from_u64(1099511627776);
+    let __v_252: G = (__v_251 * __v_124);
+    let __v_253: G = G::from_u64(281474976710656);
+    let __v_254: G = (__v_253 * __v_125);
+    let __v_255: G = G::from_u64(72057594037927936);
+    let __v_256: G = (__v_255 * __v_126);
+    let __v_257: G = (__v_254 + __v_256);
+    let __v_258: G = (__v_252 + __v_257);
+    let __v_259: G = (__v_250 + __v_258);
+    let __v_260: G = (__v_248 + __v_259);
+    let __v_261: G = (__v_246 + __v_260);
+    let __v_262: G = (__v_244 + __v_261);
+    let __v_263: G = (__v_119 + __v_262);
+    let __v_264: G = G::from_u64(256);
+    let __v_265: G = (__v_264 * __v_128);
+    let __v_266: G = G::from_u64(65536);
+    let __v_267: G = (__v_266 * __v_129);
+    let __v_268: G = G::from_u64(16777216);
+    let __v_269: G = (__v_268 * __v_130);
+    let __v_270: G = G::from_u64(4294967296);
+    let __v_271: G = (__v_270 * __v_131);
+    let __v_272: G = G::from_u64(1099511627776);
+    let __v_273: G = (__v_272 * __v_132);
+    let __v_274: G = G::from_u64(281474976710656);
+    let __v_275: G = (__v_274 * __v_133);
+    let __v_276: G = G::from_u64(72057594037927936);
+    let __v_277: G = (__v_276 * __v_134);
+    let __v_278: G = (__v_275 + __v_277);
+    let __v_279: G = (__v_273 + __v_278);
+    let __v_280: G = (__v_271 + __v_279);
+    let __v_281: G = (__v_269 + __v_280);
+    let __v_282: G = (__v_267 + __v_281);
+    let __v_283: G = (__v_265 + __v_282);
+    let __v_284: G = (__v_127 + __v_283);
+    let __v_285: G = G::from_u64(256);
+    let __v_286: G = (__v_285 * __v_142);
+    let __v_287: G = G::from_u64(65536);
+    let __v_288: G = (__v_287 * __v_143);
+    let __v_289: G = G::from_u64(16777216);
+    let __v_290: G = (__v_289 * __v_144);
+    let __v_291: G = G::from_u64(4294967296);
+    let __v_292: G = (__v_291 * __v_145);
+    let __v_293: G = G::from_u64(1099511627776);
+    let __v_294: G = (__v_293 * __v_146);
+    let __v_295: G = G::from_u64(281474976710656);
+    let __v_296: G = (__v_295 * __v_147);
+    let __v_297: G = G::from_u64(72057594037927936);
+    let __v_298: G = (__v_297 * __v_148);
+    let __v_299: G = (__v_296 + __v_298);
+    let __v_300: G = (__v_294 + __v_299);
+    let __v_301: G = (__v_292 + __v_300);
+    let __v_302: G = (__v_290 + __v_301);
+    let __v_303: G = (__v_288 + __v_302);
+    let __v_304: G = (__v_286 + __v_303);
+    let __v_305: G = (__v_141 + __v_304);
+    let __v_306: G = G::from_u64(256);
+    let __v_307: G = (__v_306 * __v_150);
+    let __v_308: G = G::from_u64(65536);
+    let __v_309: G = (__v_308 * __v_151);
+    let __v_310: G = G::from_u64(16777216);
+    let __v_311: G = (__v_310 * __v_152);
+    let __v_312: G = G::from_u64(4294967296);
+    let __v_313: G = (__v_312 * __v_153);
+    let __v_314: G = G::from_u64(1099511627776);
+    let __v_315: G = (__v_314 * __v_154);
+    let __v_316: G = G::from_u64(281474976710656);
+    let __v_317: G = (__v_316 * __v_155);
+    let __v_318: G = G::from_u64(72057594037927936);
+    let __v_319: G = (__v_318 * __v_156);
+    let __v_320: G = (__v_317 + __v_319);
+    let __v_321: G = (__v_315 + __v_320);
+    let __v_322: G = (__v_313 + __v_321);
+    let __v_323: G = (__v_311 + __v_322);
+    let __v_324: G = (__v_309 + __v_323);
+    let __v_325: G = (__v_307 + __v_324);
+    let __v_326: G = (__v_149 + __v_325);
+    let __ret: [G; OUT_175] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
+    if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_176: usize = 3;
+const IN_176: usize = 3;
+const OUT_176: usize = 2;
+fn aiur_fn_176(
+  inp: [G; IN_176],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_176], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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_176] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_3: G = (__v_0 * __v_0);
+        let __v_4: G = G::from_u64(7);
+        let __v_5: G = (__v_1 * __v_1);
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_3 + __v_6);
+        let __v_8: G = (__v_0 * __v_1);
+        let __v_9: G = (__v_1 * __v_0);
+        let __v_10: G = (__v_8 + __v_9);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_2 - __v_11);
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_7, __v_10, __v_12]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_176] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_177: usize = 1;
+const IN_177: usize = 1;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_177] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      32u64 => {
+        let __v_1: G = G::from_u64(1753635133440165772);
+        let __ret: [G; OUT_177] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = (__v_0 + __v_1);
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = (__v_3 * __v_3);
+        let __ret: [G; OUT_177] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_178: usize = 3;
+const IN_178: usize = 3;
+const OUT_178: usize = 2;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __ret: [G; OUT_178] = [__v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_179: usize = 1;
+const IN_179: usize = 1;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_179] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_0 - __v_2);
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_3]; 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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = (__v_1 * __v_4);
+        let __ret: [G; OUT_179] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_180: usize = 3;
+const IN_180: usize = 3;
+const OUT_180: usize = 8;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __v_10: G = g_inverse_value(__v_9);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_9 * __v_13);
+    let __v_15: G = G::from_u64(0);
+    if (__v_14 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __v_16: G = (__v_10 * __v_13);
+    let __v_17: G = G::from_u64(0);
+    if (__v_16 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
+    }
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = (__v_0 - __v_18);
+    let __v_21: G = (__v_1 - __v_19);
+    let __v_22: G = (__v_20 * __v_20);
+    let __v_23: G = G::from_u64(7);
+    let __v_24: G = (__v_21 * __v_21);
+    let __v_25: G = (__v_23 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    let __v_27: G = g_inverse_value(__v_26);
+    let __v_28: G = (__v_26 * __v_27);
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = (__v_28 - __v_29);
+    let __v_31: G = (__v_26 * __v_30);
+    let __v_32: G = G::from_u64(0);
+    if (__v_31 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+    }
+    let __v_33: G = (__v_27 * __v_30);
+    let __v_34: G = G::from_u64(0);
+    if (__v_33 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
+    }
+    let __v_35: G = (__v_20 * __v_27);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = (__v_36 - __v_21);
+    let __v_38: G = (__v_37 * __v_27);
+    let __v_39: G = (__v_7 * __v_35);
+    let __v_40: G = G::from_u64(7);
+    let __v_41: G = (__v_8 * __v_38);
+    let __v_42: G = (__v_40 * __v_41);
+    let __v_43: G = (__v_39 + __v_42);
+    let __v_44: G = (__v_7 * __v_38);
+    let __v_45: G = (__v_8 * __v_35);
+    let __v_46: G = (__v_44 + __v_45);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = (__v_0 - __v_10);
+    let __v_49: G = (__v_1 - __v_47);
+    let __v_50: G = (__v_48 * __v_48);
+    let __v_51: G = G::from_u64(7);
+    let __v_52: G = (__v_49 * __v_49);
+    let __v_53: G = (__v_51 * __v_52);
+    let __v_54: G = (__v_50 - __v_53);
+    let __v_55: G = g_inverse_value(__v_54);
+    let __v_56: G = (__v_54 * __v_55);
+    let __v_57: G = G::from_u64(1);
+    let __v_58: G = (__v_56 - __v_57);
+    let __v_59: G = (__v_54 * __v_58);
+    let __v_60: G = G::from_u64(0);
+    if (__v_59 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    }
+    let __v_61: G = (__v_55 * __v_58);
+    let __v_62: G = G::from_u64(0);
+    if (__v_61 != __v_62) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
+    }
+    let __v_63: G = (__v_48 * __v_55);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = (__v_64 - __v_49);
+    let __v_66: G = (__v_65 * __v_55);
+    let __v_67: G = (__v_7 * __v_63);
+    let __v_68: G = G::from_u64(7);
+    let __v_69: G = (__v_8 * __v_66);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_67 + __v_70);
+    let __v_72: G = (__v_7 * __v_66);
+    let __v_73: G = (__v_8 * __v_63);
+    let __v_74: G = (__v_72 + __v_73);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = (__v_0 - __v_10);
+    let __v_77: G = (__v_1 - __v_75);
+    let __v_78: G = (__v_7 * __v_7);
+    let __v_79: G = G::from_u64(7);
+    let __v_80: G = (__v_8 * __v_8);
+    let __v_81: G = (__v_79 * __v_80);
+    let __v_82: G = (__v_78 - __v_81);
+    let __v_83: G = g_inverse_value(__v_82);
+    let __v_84: G = (__v_82 * __v_83);
+    let __v_85: G = G::from_u64(1);
+    let __v_86: G = (__v_84 - __v_85);
+    let __v_87: G = (__v_82 * __v_86);
+    let __v_88: G = G::from_u64(0);
+    if (__v_87 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
+    }
+    let __v_89: G = (__v_83 * __v_86);
+    let __v_90: G = G::from_u64(0);
+    if (__v_89 != __v_90) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
+    }
+    let __v_91: G = (__v_7 * __v_83);
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = (__v_92 - __v_8);
+    let __v_94: G = (__v_93 * __v_83);
+    let __ret: [G; OUT_180] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
+    if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_181: usize = 24;
+const IN_181: usize = 24;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+        let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        if (__v_27 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+        if (__v_28 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        if (__v_29 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+        let __v_31: G = G::from_u64(1);
+        if (__v_30 != __v_31) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+        }
+        let __v_32: G = G::from_u64(1);
+        let __ret: [G; OUT_181] = [__v_32];
+        if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_182: usize = 6;
+const IN_182: usize = 6;
+const OUT_182: usize = 2;
+fn aiur_fn_182(
+  inp: [G; IN_182],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_182], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 = (__v_0 * __v_2);
+    let __v_7: G = G::from_u64(7);
+    let __v_8: G = (__v_1 * __v_3);
+    let __v_9: G = (__v_7 * __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_0 * __v_3);
+    let __v_12: G = (__v_1 * __v_2);
+    let __v_13: G = (__v_11 + __v_12);
+    let __v_14: G = (__v_10 + __v_4);
+    let __v_15: G = (__v_13 + __v_5);
+    let __ret: [G; OUT_182] = [__v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_183: usize = 4;
+const IN_183: usize = 4;
+const OUT_183: usize = 2;
+fn aiur_fn_183(
+  inp: [G; IN_183],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_183], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = (__v_2 * __v_4);
+    let __v_7: G = G::from_u64(7);
+    let __v_8: G = (__v_3 * __v_5);
+    let __v_9: G = (__v_7 * __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_2 * __v_5);
+    let __v_12: G = (__v_3 * __v_4);
+    let __v_13: G = (__v_11 + __v_12);
+    let __v_14: G = (__v_0 + __v_10);
+    let __v_15: G = (__v_1 + __v_13);
+    let __ret: [G; OUT_183] = [__v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_184], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_184] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2, __v_3, __v_6, __v_7]; 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 { let __r = record.function_queries[183].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_8]; 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 { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_184] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_185: usize = 15;
+const IN_185: usize = 15;
+const OUT_185: usize = 2;
+fn aiur_fn_185(
+  inp: [G; IN_185],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_185], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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 = __r_arr[1];
+    let __v_17: G = __r_arr[2];
+    let __v_18: G = __r_arr[3];
+    match __v_15.as_canonical_u64() {
+      0u64 => {
+        let __v_19: G = G::from_u64(0);
+        let __ret: [G; OUT_185] = [__v_16, __v_19];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_19: G = (__v_16 + __v_17);
+        let __v_20: G = (__v_16 + __v_19);
+        match __v_20.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_4, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_6, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __ret: [G; OUT_185] = [__v_19, __v_20];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __ret: [G; OUT_185] = [__v_9, __v_10];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __ret: [G; OUT_185] = [__v_11, __v_12];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_185] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 + __v_21);
+        let __v_24: G = (__v_20 + __v_22);
+        let __ret: [G; OUT_185] = [__v_23, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 - __v_21);
+        let __v_24: G = (__v_20 - __v_22);
+        let __ret: [G; OUT_185] = [__v_23, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 * __v_21);
+        let __v_24: G = G::from_u64(7);
+        let __v_25: G = (__v_20 * __v_22);
+        let __v_26: G = (__v_24 * __v_25);
+        let __v_27: G = (__v_23 + __v_26);
+        let __v_28: G = (__v_19 * __v_22);
+        let __v_29: G = (__v_20 * __v_21);
+        let __v_30: G = (__v_28 + __v_29);
+        let __ret: [G; OUT_185] = [__v_27, __v_30];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = (__v_21 - __v_19);
+        let __v_23: G = G::from_u64(0);
+        let __v_24: G = (__v_23 - __v_20);
+        let __ret: [G; OUT_185] = [__v_22, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_186: usize = 19;
+const IN_186: usize = 19;
+const OUT_186: usize = 2;
+fn aiur_fn_186(
+  inp: [G; IN_186],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_186], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_19: G = __loaded[0];
+    let __v_20: G = __loaded[1];
+    let __v_21: G = __loaded[2];
+    match __v_19.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_186] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __ret: [G; OUT_186] = [__v_26, __v_27];
+        if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_187: usize = 8;
+const IN_187: usize = 8;
+const OUT_187: usize = 4;
+fn aiur_fn_187(
+  inp: [G; IN_187],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_187], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 = (__v_0 * __v_4);
+    let __v_9: G = G::from_u64(7);
+    let __v_10: G = (__v_1 * __v_5);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = (__v_8 + __v_11);
+    let __v_13: G = (__v_0 * __v_5);
+    let __v_14: G = (__v_1 * __v_4);
+    let __v_15: G = (__v_13 + __v_14);
+    let __v_16: G = G::from_u64(7);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = (__v_2 * __v_6);
+    let __v_19: G = G::from_u64(7);
+    let __v_20: G = (__v_3 * __v_7);
+    let __v_21: G = (__v_19 * __v_20);
+    let __v_22: G = (__v_18 + __v_21);
+    let __v_23: G = (__v_2 * __v_7);
+    let __v_24: G = (__v_3 * __v_6);
+    let __v_25: G = (__v_23 + __v_24);
+    let __v_26: G = (__v_16 * __v_22);
+    let __v_27: G = G::from_u64(7);
+    let __v_28: G = (__v_17 * __v_25);
+    let __v_29: G = (__v_27 * __v_28);
+    let __v_30: G = (__v_26 + __v_29);
+    let __v_31: G = (__v_16 * __v_25);
+    let __v_32: G = (__v_17 * __v_22);
+    let __v_33: G = (__v_31 + __v_32);
+    let __v_34: G = (__v_0 * __v_6);
+    let __v_35: G = G::from_u64(7);
+    let __v_36: G = (__v_1 * __v_7);
+    let __v_37: G = (__v_35 * __v_36);
+    let __v_38: G = (__v_34 + __v_37);
+    let __v_39: G = (__v_0 * __v_7);
+    let __v_40: G = (__v_1 * __v_6);
+    let __v_41: G = (__v_39 + __v_40);
+    let __v_42: G = (__v_2 * __v_4);
+    let __v_43: G = G::from_u64(7);
+    let __v_44: G = (__v_3 * __v_5);
+    let __v_45: G = (__v_43 * __v_44);
+    let __v_46: G = (__v_42 + __v_45);
+    let __v_47: G = (__v_2 * __v_5);
+    let __v_48: G = (__v_3 * __v_4);
+    let __v_49: G = (__v_47 + __v_48);
+    let __v_50: G = (__v_12 + __v_30);
+    let __v_51: G = (__v_15 + __v_33);
+    let __v_52: G = (__v_38 + __v_46);
+    let __v_53: G = (__v_41 + __v_49);
+    let __ret: [G; OUT_187] = [__v_50, __v_51, __v_52, __v_53];
+    if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_188: usize = 19;
+const IN_188: usize = 19;
+const OUT_188: usize = 4;
+fn aiur_fn_188(
+  inp: [G; IN_188],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_188], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_19: G = __loaded[0];
+    let __v_20: G = __loaded[1];
+    let __v_21: G = __loaded[2];
+    match __v_19.as_canonical_u64() {
+      1u64 => {
+        let __v_22: G = G::from_u64(0);
+        let __v_23: G = G::from_u64(0);
+        let __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __ret: [G; OUT_188] = [__v_22, __v_23, __v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = __r_arr[2];
+        let __v_25: G = __r_arr[3];
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __v_28: G = __r_arr[2];
+        let __v_29: G = __r_arr[3];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+        let __v_31: G = __r_arr[1];
+        let __v_32: G = (__v_26 + __v_30);
+        let __v_33: G = (__v_27 + __v_31);
+        let __ret: [G; OUT_188] = [__v_32, __v_33, __v_28, __v_29];
+        if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_189: usize = 44;
+const IN_189: usize = 44;
+const OUT_189: usize = 2;
+fn aiur_fn_189(
+  inp: [G; IN_189],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_189], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    let __v_47: G = __loaded[3];
+    match __v_44.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_189] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_45.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+            let __v_49: G = __r_arr[1];
+            let __v_50: G = __r_arr[2];
+            let __v_51: G = __r_arr[3];
+            let __v_52: G = (__v_48 + __v_22);
+            let __v_53: G = (__v_49 + __v_23);
+            let __v_54: G = (__v_50 + __v_24);
+            let __v_55: G = (__v_51 + __v_25);
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
+            let __v_57: G = __r_arr[1];
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_58: G = __r_arr[0];
+            let __v_59: G = __r_arr[1];
+            let __v_60: G = __r_arr[2];
+            let __v_61: G = __r_arr[3];
+            let __v_62: G = (__v_56 * __v_10);
+            let __v_63: G = G::from_u64(7);
+            let __v_64: G = (__v_57 * __v_11);
+            let __v_65: G = (__v_63 * __v_64);
+            let __v_66: G = (__v_62 + __v_65);
+            let __v_67: G = (__v_56 * __v_11);
+            let __v_68: G = (__v_57 * __v_10);
+            let __v_69: G = (__v_67 + __v_68);
+            let __v_70: G = (__v_58 + __v_66);
+            let __v_71: G = (__v_59 + __v_69);
+            let __v_72: G = (__v_56 * __v_12);
+            let __v_73: G = G::from_u64(7);
+            let __v_74: G = (__v_57 * __v_13);
+            let __v_75: G = (__v_73 * __v_74);
+            let __v_76: G = (__v_72 + __v_75);
+            let __v_77: G = (__v_56 * __v_13);
+            let __v_78: G = (__v_57 * __v_12);
+            let __v_79: G = (__v_77 + __v_78);
+            let __v_80: G = (__v_60 + __v_76);
+            let __v_81: G = (__v_61 + __v_79);
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+            let __v_83: G = __r_arr[1];
+            let __v_84: G = __r_arr[2];
+            let __v_85: G = __r_arr[3];
+            let __v_86: G = G::from_u64(1);
+            let __v_87: G = (__v_86 - __v_6);
+            let __v_88: G = (__v_5 + __v_87);
+            match __v_88.as_canonical_u64() {
+              0u64 => {
+                let __v_89: G = (__v_7 + __v_7);
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_89]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_90: G = __r_arr[0];
+                let __v_91: G = __r_arr[1];
+                let __v_92: G = G::from_u64(1);
+                let __v_93: G = (__v_7 + __v_92);
+                let __v_94: G = (__v_7 + __v_93);
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_94]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+                let __v_96: G = __r_arr[1];
+                let __v_97: G = G::from_u64(0);
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_97]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+                let __v_99: G = __r_arr[1];
+                let __v_100: G = (__v_98 + __v_18);
+                let __v_101: G = (__v_99 + __v_19);
+                let __v_102: G = G::from_u64(1);
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_102]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_103: G = __r_arr[0];
+                let __v_104: G = __r_arr[1];
+                let __v_105: G = (__v_103 + __v_20);
+                let __v_106: G = (__v_104 + __v_21);
+                let __v_107: G = (__v_100 - __v_90);
+                let __v_108: G = (__v_101 - __v_91);
+                let __v_109: G = (__v_105 - __v_95);
+                let __v_110: G = (__v_106 - __v_96);
+                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_111: G = __r_arr[0];
+                let __v_112: G = __r_arr[1];
+                let __v_113: G = __r_arr[2];
+                let __v_114: G = __r_arr[3];
+                let __v_115: G = (__v_111 - __v_70);
+                let __v_116: G = (__v_112 - __v_71);
+                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_117: G = __r_arr[0];
+                let __v_118: G = __r_arr[1];
+                let __v_119: G = (__v_113 - __v_80);
+                let __v_120: G = (__v_114 - __v_81);
+                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_121: G = __r_arr[0];
+                let __v_122: G = __r_arr[1];
+                let __ret: [G; OUT_189] = [__v_121, __v_122];
+                if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_89: G = G::from_u64(1);
+                let __v_90: G = (__v_8 - __v_89);
+                match __v_90.as_canonical_u64() {
+                  0u64 => {
+                    let __v_91: G = (__v_7 + __v_7);
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_91]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_92: G = __r_arr[0];
+                    let __v_93: G = __r_arr[1];
+                    let __v_94: G = G::from_u64(1);
+                    let __v_95: G = (__v_7 + __v_94);
+                    let __v_96: G = (__v_7 + __v_95);
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_96]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_97: G = __r_arr[0];
+                    let __v_98: G = __r_arr[1];
+                    let __v_99: G = G::from_u64(2);
+                    let __v_100: G = (__v_7 + __v_99);
+                    let __v_101: G = (__v_7 + __v_100);
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_101]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_102: G = __r_arr[0];
+                    let __v_103: G = __r_arr[1];
+                    let __v_104: G = G::from_u64(3);
+                    let __v_105: G = (__v_7 + __v_104);
+                    let __v_106: G = (__v_7 + __v_105);
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_106]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_107: G = __r_arr[0];
+                    let __v_108: G = __r_arr[1];
+                    let __v_109: G = (__v_102 - __v_92);
+                    let __v_110: G = (__v_103 - __v_93);
+                    let __v_111: G = (__v_107 - __v_97);
+                    let __v_112: G = (__v_108 - __v_98);
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_113: G = __r_arr[0];
+                    let __v_114: G = __r_arr[1];
+                    let __v_115: G = __r_arr[2];
+                    let __v_116: G = __r_arr[3];
+                    let __v_117: G = (__v_113 - __v_70);
+                    let __v_118: G = (__v_114 - __v_71);
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+                    let __v_120: G = __r_arr[1];
+                    let __v_121: G = (__v_115 - __v_80);
+                    let __v_122: G = (__v_116 - __v_81);
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+                    let __v_124: G = __r_arr[1];
+                    let __v_125: G = G::from_u64(1);
+                    let __v_126: G = (__v_5 + __v_125);
+                    let __v_127: G = G::from_u64(1);
+                    let __v_128: G = (__v_7 + __v_127);
+                    let __v_129: G = G::from_u64(1);
+                    let __v_130: G = G::from_u64(0);
+                    let __v_131: G = G::from_u64(0);
+                    let __v_132: G = G::from_u64(0);
+                    let __v_133: G = G::from_u64(0);
+                    let __v_134: G = G::from_u64(0);
+                    let __v_135: G = G::from_u64(0);
+                    let __v_136: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_137: G = __r_arr[0];
+                    let __v_138: G = __r_arr[1];
+                    let __ret: [G; OUT_189] = [__v_137, __v_138];
+                    if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_91: G = G::from_u64(1);
+                    let __v_92: G = (__v_5 + __v_91);
+                    let __v_93: G = G::from_u64(1);
+                    let __v_94: G = (__v_8 - __v_93);
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+                    let __v_96: G = __r_arr[1];
+                    let __ret: [G; OUT_189] = [__v_95, __v_96];
+                    if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_190: usize = 28;
+const IN_190: usize = 28;
+const OUT_190: usize = 2;
+fn aiur_fn_190(
+  inp: [G; IN_190],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_190], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(0);
+    let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(0);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = (__v_17 - __v_15);
+    let __v_41: G = (__v_38 - __v_36);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = (__v_40 * __v_27);
+    let __v_44: G = G::from_u64(7);
+    let __v_45: G = (__v_41 * __v_42);
+    let __v_46: G = (__v_44 * __v_45);
+    let __v_47: G = (__v_43 + __v_46);
+    let __v_48: G = (__v_40 * __v_42);
+    let __v_49: G = (__v_41 * __v_27);
+    let __v_50: G = (__v_48 + __v_49);
+    let __v_51: G = (__v_21 * __v_47);
+    let __v_52: G = G::from_u64(7);
+    let __v_53: G = (__v_22 * __v_50);
+    let __v_54: G = (__v_52 * __v_53);
+    let __v_55: G = (__v_51 + __v_54);
+    let __v_56: G = (__v_21 * __v_50);
+    let __v_57: G = (__v_22 * __v_47);
+    let __v_58: G = (__v_56 + __v_57);
+    let __v_59: G = (__v_18 - __v_16);
+    let __v_60: G = (__v_39 - __v_37);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = (__v_59 * __v_27);
+    let __v_63: G = G::from_u64(7);
+    let __v_64: G = (__v_60 * __v_61);
+    let __v_65: G = (__v_63 * __v_64);
+    let __v_66: G = (__v_62 + __v_65);
+    let __v_67: G = (__v_59 * __v_61);
+    let __v_68: G = (__v_60 * __v_27);
+    let __v_69: G = (__v_67 + __v_68);
+    let __v_70: G = (__v_21 * __v_66);
+    let __v_71: G = G::from_u64(7);
+    let __v_72: G = (__v_22 * __v_69);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_70 + __v_73);
+    let __v_75: G = (__v_21 * __v_69);
+    let __v_76: G = (__v_22 * __v_66);
+    let __v_77: G = (__v_75 + __v_76);
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_78: G = __loaded[0];
+    let __v_79: G = __loaded[1];
+    let __v_80: G = __loaded[2];
+    let __v_81: G = __loaded[3];
+    match __v_78.as_canonical_u64() {
+      1u64 => {
+        let __v_82: G = G::from_u64(0);
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_82]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+        let __v_84: G = __r_arr[1];
+        let __v_85: G = G::from_u64(0);
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_85]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_86: G = __r_arr[0];
+        let __v_87: G = __r_arr[1];
+        let __v_88: G = (__v_83 - __v_86);
+        let __v_89: G = (__v_84 - __v_87);
+        let __v_90: G = (__v_88 + __v_55);
+        let __v_91: G = (__v_89 + __v_58);
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_92: G = __r_arr[0];
+        let __v_93: G = __r_arr[1];
+        let __v_94: G = G::from_u64(1);
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_94]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+        let __v_96: G = __r_arr[1];
+        let __v_97: G = G::from_u64(1);
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_97]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+        let __v_99: G = __r_arr[1];
+        let __v_100: G = (__v_95 - __v_98);
+        let __v_101: G = (__v_96 - __v_99);
+        let __v_102: G = (__v_100 + __v_74);
+        let __v_103: G = (__v_101 + __v_77);
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
+        let __ret: [G; OUT_190] = [__v_104, __v_105];
+        if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_82: G = G::from_u64(0);
+        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+        let __v_84: G = G::from_u64(0);
+        let __v_85: G = G::from_u64(1);
+        let __v_86: G = G::from_u64(0);
+        let __v_87: G = G::from_u64(0);
+        let __v_88: G = G::from_u64(0);
+        let __v_89: G = G::from_u64(0);
+        let __v_90: G = G::from_u64(0);
+        let __v_91: G = G::from_u64(0);
+        let __v_92: G = G::from_u64(0);
+        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_93: G = __r_arr[0];
+        let __v_94: G = __r_arr[1];
+        let __ret: [G; OUT_190] = [__v_93, __v_94];
+        if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_78.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_191: usize = 8;
+const IN_191: usize = 8;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_191], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(1);
+    let __v_25: G = G::from_u64(1);
+    let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_191] = [__v_34];
+    if !unconstrained { record.virt += record.function_queries[191].weight(); } record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_192: usize = 5;
+const IN_192: usize = 5;
+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_192], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    let __v_8: G = __loaded[3];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_192] = [__v_9, __v_10];
+        if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_9: G = (__v_3 * __v_6);
+        let __v_10: G = G::from_u64(7);
+        let __v_11: G = (__v_4 * __v_7);
+        let __v_12: G = (__v_10 * __v_11);
+        let __v_13: G = (__v_9 + __v_12);
+        let __v_14: G = (__v_3 * __v_7);
+        let __v_15: G = (__v_4 * __v_6);
+        let __v_16: G = (__v_14 + __v_15);
+        let __v_17: G = (__v_3 * __v_1);
+        let __v_18: G = G::from_u64(7);
+        let __v_19: G = (__v_4 * __v_2);
+        let __v_20: G = (__v_18 * __v_19);
+        let __v_21: G = (__v_17 + __v_20);
+        let __v_22: G = (__v_3 * __v_2);
+        let __v_23: G = (__v_4 * __v_1);
+        let __v_24: G = (__v_22 + __v_23);
+        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_1, __v_2, __v_21, __v_24]; 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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __v_27: G = (__v_13 + __v_25);
+        let __v_28: G = (__v_16 + __v_26);
+        let __ret: [G; OUT_192] = [__v_27, __v_28];
+        if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_193: usize = 1;
+const IN_193: usize = 1;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_193], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(32);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_194: usize = 4;
+const IN_194: usize = 4;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_194] = [__v_6, __v_9];
+        if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_194] = [__v_6, __v_9];
+            if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+            let __v_5: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_5]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = G::from_u64(1);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_194] = [__v_6, __v_8];
+            if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_195: usize = 20;
+const IN_195: usize = 20;
+const OUT_195: usize = 1;
+fn aiur_fn_195(
+  inp: [G; IN_195],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_195], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_20: G = __loaded[0];
+    let __v_21: G = __loaded[1];
+    let __v_22: G = __loaded[2];
+    let __v_23: G = __loaded[3];
+    let __v_24: G = __loaded[4];
+    let __v_25: G = __loaded[5];
+    let __v_26: G = __loaded[6];
+    let __v_27: G = __loaded[7];
+    match __v_20.as_canonical_u64() {
+      1u64 => {
+        let __v_28: G = G::from_u64(1);
+        let __ret: [G; OUT_195] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_21.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_9]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_24]; 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 { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_9]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+            let __v_33: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_33]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+            let __v_35: G = G::from_u64(1);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_35]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_9]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+            let __v_38: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+            let __v_40: G = G::from_u64(1);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_40]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+            let __v_43: G = __r_arr[1];
+            let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() {
+  0u64 => {
+    let __v_44: G = G::from_u64(1);
+    let __v_45: G = G::from_u64(1);
+    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_46, __v_49];
+  },
+  1u64 => {
+    match __v_6.as_canonical_u64() {
+      0u64 => {
+        let __v_44: G = G::from_u64(1);
+        let __v_45: G = G::from_u64(1);
+        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_47: G = G::from_u64(1);
+        let __v_48: G = G::from_u64(1);
+        let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        break '__mc_0 [__v_46, __v_49];
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __v_43]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = G::from_u64(0);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_45]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __v_47: G = G::from_u64(1);
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_47]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+        break '__mc_0 [__v_46, __v_48];
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
+  },
+}
+ };
+            let __v_44: G = __mc_out___mc_0[0];
+            let __v_45: G = __mc_out___mc_0[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_18, __v_19, __v_28]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+            let __v_47: G = __r_arr[1];
+            let __v_48: G = G::from_u64(1);
+            let __v_49: G = G::from_u64(0);
+            let __v_50: G = (__v_46 - __v_48);
+            let __v_51: G = (__v_47 - __v_49);
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+            let __v_53: G = g_inverse_value(__v_52);
+            let __v_54: G = (__v_52 * __v_53);
+            let __v_55: G = G::from_u64(1);
+            let __v_56: G = (__v_54 - __v_55);
+            let __v_57: G = (__v_52 * __v_56);
+            let __v_58: G = G::from_u64(0);
+            if (__v_57 != __v_58) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+            }
+            let __v_59: G = (__v_53 * __v_56);
+            let __v_60: G = G::from_u64(0);
+            if (__v_59 != __v_60) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+            }
+            let __v_61: G = G::from_u64(1);
+            let __v_62: G = G::from_u64(0);
+            let __v_63: G = (__v_18 - __v_61);
+            let __v_64: G = (__v_19 - __v_62);
+            let __v_65: G = (__v_63 * __v_63);
+            let __v_66: G = G::from_u64(7);
+            let __v_67: G = (__v_64 * __v_64);
+            let __v_68: G = (__v_66 * __v_67);
+            let __v_69: G = (__v_65 - __v_68);
+            let __v_70: G = g_inverse_value(__v_69);
+            let __v_71: G = (__v_69 * __v_70);
+            let __v_72: G = G::from_u64(1);
+            let __v_73: G = (__v_71 - __v_72);
+            let __v_74: G = (__v_69 * __v_73);
+            let __v_75: G = G::from_u64(0);
+            if (__v_74 != __v_75) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+            }
+            let __v_76: G = (__v_70 * __v_73);
+            let __v_77: G = G::from_u64(0);
+            if (__v_76 != __v_77) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+            }
+            let __v_78: G = (__v_63 * __v_70);
+            let __v_79: G = G::from_u64(0);
+            let __v_80: G = (__v_79 - __v_64);
+            let __v_81: G = (__v_80 * __v_70);
+            let __v_82: G = (__v_50 * __v_78);
+            let __v_83: G = G::from_u64(7);
+            let __v_84: G = (__v_51 * __v_81);
+            let __v_85: G = (__v_83 * __v_84);
+            let __v_86: G = (__v_82 + __v_85);
+            let __v_87: G = (__v_50 * __v_81);
+            let __v_88: G = (__v_51 * __v_78);
+            let __v_89: G = (__v_87 + __v_88);
+            let __v_90: G = G::from_u64(0);
+            let __v_91: G = (__v_18 - __v_53);
+            let __v_92: G = (__v_19 - __v_90);
+            let __v_93: G = (__v_91 * __v_91);
+            let __v_94: G = G::from_u64(7);
+            let __v_95: G = (__v_92 * __v_92);
+            let __v_96: G = (__v_94 * __v_95);
+            let __v_97: G = (__v_93 - __v_96);
+            let __v_98: G = g_inverse_value(__v_97);
+            let __v_99: G = (__v_97 * __v_98);
+            let __v_100: G = G::from_u64(1);
+            let __v_101: G = (__v_99 - __v_100);
+            let __v_102: G = (__v_97 * __v_101);
+            let __v_103: G = G::from_u64(0);
+            if (__v_102 != __v_103) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
+            }
+            let __v_104: G = (__v_98 * __v_101);
+            let __v_105: G = G::from_u64(0);
+            if (__v_104 != __v_105) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
+            }
+            let __v_106: G = (__v_91 * __v_98);
+            let __v_107: G = G::from_u64(0);
+            let __v_108: G = (__v_107 - __v_92);
+            let __v_109: G = (__v_108 * __v_98);
+            let __v_110: G = (__v_50 * __v_106);
+            let __v_111: G = G::from_u64(7);
+            let __v_112: G = (__v_51 * __v_109);
+            let __v_113: G = (__v_111 * __v_112);
+            let __v_114: G = (__v_110 + __v_113);
+            let __v_115: G = (__v_50 * __v_109);
+            let __v_116: G = (__v_51 * __v_106);
+            let __v_117: G = (__v_115 + __v_116);
+            let __v_118: G = G::from_u64(0);
+            let __v_119: G = (__v_18 - __v_53);
+            let __v_120: G = (__v_19 - __v_118);
+            let __v_121: G = (__v_50 * __v_50);
+            let __v_122: G = G::from_u64(7);
+            let __v_123: G = (__v_51 * __v_51);
+            let __v_124: G = (__v_122 * __v_123);
+            let __v_125: G = (__v_121 - __v_124);
+            let __v_126: G = g_inverse_value(__v_125);
+            let __v_127: G = (__v_125 * __v_126);
+            let __v_128: G = G::from_u64(1);
+            let __v_129: G = (__v_127 - __v_128);
+            let __v_130: G = (__v_125 * __v_129);
+            let __v_131: G = G::from_u64(0);
+            if (__v_130 != __v_131) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+            }
+            let __v_132: G = (__v_126 * __v_129);
+            let __v_133: G = G::from_u64(0);
+            if (__v_132 != __v_133) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_133.as_canonical_u64(), msg: None });
+            }
+            let __v_134: G = (__v_50 * __v_126);
+            let __v_135: G = G::from_u64(0);
+            let __v_136: G = (__v_135 - __v_51);
+            let __v_137: G = (__v_136 * __v_126);
+            let __v_138: G = G::from_u64(0);
+            let __v_139: G = G::from_u64(0);
+            let __v_140: G = G::from_u64(0);
+            let __v_141: G = G::from_u64(0);
+            let __v_142: G = G::from_u64(0);
+            let __v_143: G = G::from_u64(0);
+            let __v_144: G = G::from_u64(0);
+            let __v_145: G = G::from_u64(0);
+            let __v_146: G = G::from_u64(0);
+            let __v_147: G = G::from_u64(0);
+            let __v_148: G = G::from_u64(0);
+            let __v_149: G = G::from_u64(0);
+            let __v_150: G = G::from_u64(0);
+            let __v_151: G = G::from_u64(0);
+            let __v_152: G = G::from_u64(0);
+            let __v_153: G = G::from_u64(0);
+            let __v_154: G = G::from_u64(1);
+            let __v_155: G = G::from_u64(1);
+            let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_28]; 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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_165: G = __r_arr[0];
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_166: G = __r_arr[0];
+            let __v_167: G = (__v_165 * __v_166);
+            let __v_168: G = g_inverse_value(__v_167);
+            let __v_169: G = (__v_167 * __v_168);
+            let __v_170: G = G::from_u64(1);
+            let __v_171: G = (__v_169 - __v_170);
+            let __v_172: G = (__v_167 * __v_171);
+            let __v_173: G = G::from_u64(0);
+            if (__v_172 != __v_173) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: None });
+            }
+            let __v_174: G = (__v_168 * __v_171);
+            let __v_175: G = G::from_u64(0);
+            if (__v_174 != __v_175) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_175.as_canonical_u64(), msg: None });
+            }
+            let __v_176: G = G::from_u64(0);
+            let __v_177: G = G::from_u64(0);
+            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_178: G = __r_arr[0];
+            let __v_179: G = __r_arr[1];
+            let __v_180: G = G::from_u64(0);
+            let __v_181: G = G::from_u64(0);
+            let __v_182: G = G::from_u64(0);
+            let __v_183: G = G::from_u64(0);
+            let __v_184: G = G::from_u64(0);
+            let __v_185: G = G::from_u64(0);
+            let __v_186: G = G::from_u64(0);
+            let __v_187: G = G::from_u64(0);
+            let __v_188: G = (__v_30 - __v_10);
+            let __v_189: G = (__v_186 - __v_184);
+            let __v_190: G = G::from_u64(0);
+            let __v_191: G = (__v_188 * __v_168);
+            let __v_192: G = G::from_u64(7);
+            let __v_193: G = (__v_189 * __v_190);
+            let __v_194: G = (__v_192 * __v_193);
+            let __v_195: G = (__v_191 + __v_194);
+            let __v_196: G = (__v_188 * __v_190);
+            let __v_197: G = (__v_189 * __v_168);
+            let __v_198: G = (__v_196 + __v_197);
+            let __v_199: G = (__v_114 * __v_195);
+            let __v_200: G = G::from_u64(7);
+            let __v_201: G = (__v_117 * __v_198);
+            let __v_202: G = (__v_200 * __v_201);
+            let __v_203: G = (__v_199 + __v_202);
+            let __v_204: G = (__v_114 * __v_198);
+            let __v_205: G = (__v_117 * __v_195);
+            let __v_206: G = (__v_204 + __v_205);
+            let __v_207: G = (__v_31 - __v_11);
+            let __v_208: G = (__v_187 - __v_185);
+            let __v_209: G = G::from_u64(0);
+            let __v_210: G = (__v_207 * __v_168);
+            let __v_211: G = G::from_u64(7);
+            let __v_212: G = (__v_208 * __v_209);
+            let __v_213: G = (__v_211 * __v_212);
+            let __v_214: G = (__v_210 + __v_213);
+            let __v_215: G = (__v_207 * __v_209);
+            let __v_216: G = (__v_208 * __v_168);
+            let __v_217: G = (__v_215 + __v_216);
+            let __v_218: G = (__v_114 * __v_214);
+            let __v_219: G = G::from_u64(7);
+            let __v_220: G = (__v_117 * __v_217);
+            let __v_221: G = (__v_219 * __v_220);
+            let __v_222: G = (__v_218 + __v_221);
+            let __v_223: G = (__v_114 * __v_217);
+            let __v_224: G = (__v_117 * __v_214);
+            let __v_225: G = (__v_223 + __v_224);
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_226: G = __loaded[0];
+            let __v_227: G = __loaded[1];
+            let __v_228: G = __loaded[2];
+            let __v_229: G = __loaded[3];
+            let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() {
+  1u64 => {
+    let __v_230: G = G::from_u64(0);
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_230]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_231: G = __r_arr[0];
+    let __v_232: G = __r_arr[1];
+    let __v_233: G = G::from_u64(0);
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_233]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_234: G = __r_arr[0];
+    let __v_235: G = __r_arr[1];
+    let __v_236: G = (__v_231 - __v_234);
+    let __v_237: G = (__v_232 - __v_235);
+    let __v_238: G = (__v_236 + __v_203);
+    let __v_239: G = (__v_237 + __v_206);
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_240: G = __r_arr[0];
+    let __v_241: G = __r_arr[1];
+    let __v_242: G = G::from_u64(1);
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_242]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_243: G = __r_arr[0];
+    let __v_244: G = __r_arr[1];
+    let __v_245: G = G::from_u64(1);
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_245]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_246: G = __r_arr[0];
+    let __v_247: G = __r_arr[1];
+    let __v_248: G = (__v_243 - __v_246);
+    let __v_249: G = (__v_244 - __v_247);
+    let __v_250: G = (__v_248 + __v_222);
+    let __v_251: G = (__v_249 + __v_225);
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_252: G = __r_arr[0];
+    let __v_253: G = __r_arr[1];
+    break '__mc_1 [__v_252, __v_253];
+  },
+  0u64 => {
+    let __v_230: G = G::from_u64(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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_231: G = __r_arr[0];
+    let __v_232: G = G::from_u64(0);
+    let __v_233: G = G::from_u64(1);
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(0);
+    let __v_237: G = G::from_u64(0);
+    let __v_238: G = G::from_u64(0);
+    let __v_239: G = G::from_u64(0);
+    let __v_240: G = G::from_u64(0);
+    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_241: G = __r_arr[0];
+    let __v_242: G = __r_arr[1];
+    break '__mc_1 [__v_241, __v_242];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_226.as_canonical_u64()));
+  },
+}
+ };
+            let __v_230: G = __mc_out___mc_1[0];
+            let __v_231: G = __mc_out___mc_1[1];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_9]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_232: G = __r_arr[0];
+            let __v_233: G = G::from_u64(0);
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_232, __v_233]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_234: G = __r_arr[0];
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_234]; 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 { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } 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_235: G = __r_arr[0];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_18, __v_19, __v_28]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_236: G = __r_arr[0];
+            let __v_237: G = __r_arr[1];
+            let __v_238: G = G::from_u64(1);
+            let __v_239: G = G::from_u64(0);
+            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_235, __v_236, __v_237, __v_238, __v_239]; 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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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_240: G = __r_arr[0];
+            let __v_241: G = __r_arr[1];
+            let __v_242: G = (__v_230 * __v_134);
+            let __v_243: G = G::from_u64(7);
+            let __v_244: G = (__v_231 * __v_137);
+            let __v_245: G = (__v_243 * __v_244);
+            let __v_246: G = (__v_242 + __v_245);
+            let __v_247: G = (__v_230 * __v_137);
+            let __v_248: G = (__v_231 * __v_134);
+            let __v_249: G = (__v_247 + __v_248);
+            let __v_250: G = G::from_u64(32);
+            let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) };
+            let __v_252: G = G::from_u64(1);
+            if (__v_251 != __v_252) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_235]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_253: G = __r_arr[0];
+            let __v_254: G = (__v_253 - __v_29);
+            let __v_255: G = G::from_bool((__v_254 == G::ZERO));
+            let __v_256: G = G::from_u64(1);
+            if (__v_255 != __v_256) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
+            }
+            let __v_257: G = (__v_246 - __v_240);
+            let __v_258: G = G::from_bool((__v_257 == G::ZERO));
+            let __v_259: G = (__v_249 - __v_241);
+            let __v_260: G = G::from_bool((__v_259 == G::ZERO));
+            let __v_261: G = (__v_258 * __v_260);
+            let __v_262: G = G::from_u64(1);
+            if (__v_261 != __v_262) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_262.as_canonical_u64(), msg: None });
+            }
+            let __v_263: G = G::from_u64(1);
+            let __v_264: G = (__v_9 + __v_263);
+            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_265: G = __r_arr[0];
+            let __ret: [G; OUT_195] = [__v_265];
+            if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_196: usize = 3;
+const IN_196: usize = 3;
+const OUT_196: usize = 2;
+fn aiur_fn_196(
+  inp: [G; IN_196],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_196], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_196] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_13: G = G::from_u64(256);
+        let __v_14: G = (__v_13 * __v_5);
+        let __v_15: G = G::from_u64(65536);
+        let __v_16: G = (__v_15 * __v_6);
+        let __v_17: G = G::from_u64(16777216);
+        let __v_18: G = (__v_17 * __v_7);
+        let __v_19: G = G::from_u64(4294967296);
+        let __v_20: G = (__v_19 * __v_8);
+        let __v_21: G = G::from_u64(1099511627776);
+        let __v_22: G = (__v_21 * __v_9);
+        let __v_23: G = G::from_u64(281474976710656);
+        let __v_24: G = (__v_23 * __v_10);
+        let __v_25: G = G::from_u64(72057594037927936);
+        let __v_26: G = (__v_25 * __v_11);
+        let __v_27: G = (__v_24 + __v_26);
+        let __v_28: G = (__v_22 + __v_27);
+        let __v_29: G = (__v_20 + __v_28);
+        let __v_30: G = (__v_18 + __v_29);
+        let __v_31: G = (__v_16 + __v_30);
+        let __v_32: G = (__v_14 + __v_31);
+        let __v_33: G = (__v_4 + __v_32);
+        let __v_34: G = G::from_u64(0);
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0, __v_1, __v_12]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+        let __v_36: G = __r_arr[1];
+        let __v_37: G = (__v_0 * __v_35);
+        let __v_38: G = G::from_u64(7);
+        let __v_39: G = (__v_1 * __v_36);
+        let __v_40: G = (__v_38 * __v_39);
+        let __v_41: G = (__v_37 + __v_40);
+        let __v_42: G = (__v_0 * __v_36);
+        let __v_43: G = (__v_1 * __v_35);
+        let __v_44: G = (__v_42 + __v_43);
+        let __v_45: G = (__v_33 + __v_41);
+        let __v_46: G = (__v_34 + __v_44);
+        let __ret: [G; OUT_196] = [__v_45, __v_46];
+        if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_197: usize = 7;
+const IN_197: usize = 7;
+const OUT_197: usize = 2;
+fn aiur_fn_197(
+  inp: [G; IN_197],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_197], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_197] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_6, __v_8]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = (__v_3 + __v_10);
+        let __v_13: G = (__v_4 + __v_11);
+        let __v_14: G = (__v_12 * __v_12);
+        let __v_15: G = G::from_u64(7);
+        let __v_16: G = (__v_13 * __v_13);
+        let __v_17: G = (__v_15 * __v_16);
+        let __v_18: G = (__v_14 - __v_17);
+        let __v_19: G = g_inverse_value(__v_18);
+        let __v_20: G = (__v_18 * __v_19);
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = (__v_20 - __v_21);
+        let __v_23: G = (__v_18 * __v_22);
+        let __v_24: G = G::from_u64(0);
+        if (__v_23 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __v_25: G = (__v_19 * __v_22);
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        }
+        let __v_27: G = (__v_12 * __v_19);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = (__v_28 - __v_13);
+        let __v_30: G = (__v_29 * __v_19);
+        let __v_31: G = (__v_0 + __v_27);
+        let __v_32: G = (__v_1 + __v_30);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+        let __v_34: G = __r_arr[1];
+        let __ret: [G; OUT_197] = [__v_33, __v_34];
+        if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_198: usize = 38;
+const IN_198: usize = 38;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_198], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        match __v_0.as_canonical_u64() {
+          _ => {
+            match __v_12.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11, __v_12]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+                match __v_13.as_canonical_u64() {
+                  _ => {
+                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
+  0u64 => {
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_42];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                    let __v_40: G = __mc_out___mc_0[0];
+                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_17, __v_37]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_13, __v_41]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_40, __v_42]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
+                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_12, __v_43]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_44]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+                    let __v_46: G = G::from_u64(0);
+                    let __v_47: G = G::from_u64(109);
+                    let __v_48: G = G::from_u64(0);
+                    let __v_49: G = G::from_u64(117);
+                    let __v_50: G = G::from_u64(0);
+                    let __v_51: G = G::from_u64(108);
+                    let __v_52: G = G::from_u64(0);
+                    let __v_53: G = G::from_u64(116);
+                    let __v_54: G = G::from_u64(0);
+                    let __v_55: G = G::from_u64(105);
+                    let __v_56: G = G::from_u64(0);
+                    let __v_57: G = G::from_u64(45);
+                    let __v_58: G = G::from_u64(0);
+                    let __v_59: G = G::from_u64(115);
+                    let __v_60: G = G::from_u64(0);
+                    let __v_61: G = G::from_u64(116);
+                    let __v_62: G = G::from_u64(0);
+                    let __v_63: G = G::from_u64(97);
+                    let __v_64: G = G::from_u64(0);
+                    let __v_65: G = G::from_u64(114);
+                    let __v_66: G = G::from_u64(0);
+                    let __v_67: G = G::from_u64(107);
+                    let __v_68: G = G::from_u64(0);
+                    let __v_69: G = G::from_u64(47);
+                    let __v_70: G = G::from_u64(0);
+                    let __v_71: G = G::from_u64(118);
+                    let __v_72: G = G::from_u64(0);
+                    let __v_73: G = G::from_u64(48);
+                    let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_88: G = G::from_u64(1);
+                    let __v_89: G = G::from_u64(1);
+                    let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_87, __v_90]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_91: G = __r_arr[0];
+                    let __v_92: G = __r_arr[1];
+                    let __v_93: G = __r_arr[2];
+                    let __v_94: G = __r_arr[3];
+                    let __v_95: G = __r_arr[4];
+                    let __v_96: G = __r_arr[5];
+                    let __v_97: G = __r_arr[6];
+                    let __v_98: G = __r_arr[7];
+                    let __v_99: G = __r_arr[8];
+                    let __v_100: G = __r_arr[9];
+                    let __v_101: G = __r_arr[10];
+                    let __v_102: G = __r_arr[11];
+                    let __v_103: G = __r_arr[12];
+                    let __v_104: G = __r_arr[13];
+                    let __v_105: G = __r_arr[14];
+                    let __v_106: G = __r_arr[15];
+                    let __v_107: G = __r_arr[16];
+                    let __v_108: G = __r_arr[17];
+                    let __v_109: G = G::from_u64(1);
+                    let __v_110: G = G::from_u64(1);
+                    let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_113: G = __r_arr[0];
+                    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_107, __v_113]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_114: G = __r_arr[0];
+                    let __v_115: G = G::from_u64(1);
+                    let __v_116: G = G::from_u64(1);
+                    let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_114, __v_117]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+                    let __v_119: G = __r_arr[1];
+                    let __v_120: G = __r_arr[2];
+                    let __v_121: G = __r_arr[3];
+                    let __v_122: G = __r_arr[4];
+                    let __v_123: G = __r_arr[5];
+                    let __v_124: G = __r_arr[6];
+                    let __v_125: G = __r_arr[7];
+                    let __v_126: G = __r_arr[8];
+                    let __v_127: G = __r_arr[9];
+                    let __v_128: G = __r_arr[10];
+                    let __v_129: G = __r_arr[11];
+                    let __v_130: G = __r_arr[12];
+                    let __v_131: G = __r_arr[13];
+                    let __v_132: G = __r_arr[14];
+                    let __v_133: G = __r_arr[15];
+                    let __v_134: G = __r_arr[16];
+                    let __v_135: G = __r_arr[17];
+                    let __v_136: G = G::from_u64(1);
+                    let __v_137: G = G::from_u64(1);
+                    let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_139: G = __r_arr[0];
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_140: G = __r_arr[0];
+                    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_134, __v_140]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_141: G = __r_arr[0];
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_141, __v_14]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_142: G = __r_arr[0];
+                    let __v_143: G = G::from_u64(1);
+                    let __v_144: G = G::from_u64(1);
+                    let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16, __v_145]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_146: G = __r_arr[0];
+                    let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_142, __v_146]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_147: G = __r_arr[0];
+                    let __v_148: G = G::from_u64(1);
+                    let __v_149: G = G::from_u64(1);
+                    let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_147, __v_150]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+                    let __v_152: G = __r_arr[1];
+                    let __v_153: G = __r_arr[2];
+                    let __v_154: G = __r_arr[3];
+                    let __v_155: G = __r_arr[4];
+                    let __v_156: G = __r_arr[5];
+                    let __v_157: G = __r_arr[6];
+                    let __v_158: G = __r_arr[7];
+                    let __v_159: G = __r_arr[8];
+                    let __v_160: G = __r_arr[9];
+                    let __v_161: G = __r_arr[10];
+                    let __v_162: G = __r_arr[11];
+                    let __v_163: G = __r_arr[12];
+                    let __v_164: G = __r_arr[13];
+                    let __v_165: G = __r_arr[14];
+                    let __v_166: G = __r_arr[15];
+                    let __v_167: G = __r_arr[16];
+                    let __v_168: G = __r_arr[17];
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_167, __v_15]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_169: G = __r_arr[0];
+                    let __v_170: G = G::from_u64(1);
+                    let __v_171: G = G::from_u64(1);
+                    let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_169, __v_172]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_173: G = __r_arr[0];
+                    let __v_174: G = __r_arr[1];
+                    let __v_175: G = __r_arr[2];
+                    let __v_176: G = __r_arr[3];
+                    let __v_177: G = __r_arr[4];
+                    let __v_178: G = __r_arr[5];
+                    let __v_179: G = __r_arr[6];
+                    let __v_180: G = __r_arr[7];
+                    let __v_181: G = __r_arr[8];
+                    let __v_182: G = __r_arr[9];
+                    let __v_183: G = __r_arr[10];
+                    let __v_184: G = __r_arr[11];
+                    let __v_185: G = __r_arr[12];
+                    let __v_186: G = __r_arr[13];
+                    let __v_187: G = __r_arr[14];
+                    let __v_188: G = __r_arr[15];
+                    let __v_189: G = __r_arr[16];
+                    let __v_190: G = __r_arr[17];
+                    let __v_191: G = G::from_u64(256);
+                    let __v_192: G = (__v_191 * __v_92);
+                    let __v_193: G = G::from_u64(65536);
+                    let __v_194: G = (__v_193 * __v_93);
+                    let __v_195: G = G::from_u64(16777216);
+                    let __v_196: G = (__v_195 * __v_94);
+                    let __v_197: G = G::from_u64(4294967296);
+                    let __v_198: G = (__v_197 * __v_95);
+                    let __v_199: G = G::from_u64(1099511627776);
+                    let __v_200: G = (__v_199 * __v_96);
+                    let __v_201: G = G::from_u64(281474976710656);
+                    let __v_202: G = (__v_201 * __v_97);
+                    let __v_203: G = G::from_u64(72057594037927936);
+                    let __v_204: G = (__v_203 * __v_98);
+                    let __v_205: G = (__v_202 + __v_204);
+                    let __v_206: G = (__v_200 + __v_205);
+                    let __v_207: G = (__v_198 + __v_206);
+                    let __v_208: G = (__v_196 + __v_207);
+                    let __v_209: G = (__v_194 + __v_208);
+                    let __v_210: G = (__v_192 + __v_209);
+                    let __v_211: G = (__v_91 + __v_210);
+                    let __v_212: G = G::from_u64(256);
+                    let __v_213: G = (__v_212 * __v_100);
+                    let __v_214: G = G::from_u64(65536);
+                    let __v_215: G = (__v_214 * __v_101);
+                    let __v_216: G = G::from_u64(16777216);
+                    let __v_217: G = (__v_216 * __v_102);
+                    let __v_218: G = G::from_u64(4294967296);
+                    let __v_219: G = (__v_218 * __v_103);
+                    let __v_220: G = G::from_u64(1099511627776);
+                    let __v_221: G = (__v_220 * __v_104);
+                    let __v_222: G = G::from_u64(281474976710656);
+                    let __v_223: G = (__v_222 * __v_105);
+                    let __v_224: G = G::from_u64(72057594037927936);
+                    let __v_225: G = (__v_224 * __v_106);
+                    let __v_226: G = (__v_223 + __v_225);
+                    let __v_227: G = (__v_221 + __v_226);
+                    let __v_228: G = (__v_219 + __v_227);
+                    let __v_229: G = (__v_217 + __v_228);
+                    let __v_230: G = (__v_215 + __v_229);
+                    let __v_231: G = (__v_213 + __v_230);
+                    let __v_232: G = (__v_99 + __v_231);
+                    let __v_233: G = G::from_u64(256);
+                    let __v_234: G = (__v_233 * __v_119);
+                    let __v_235: G = G::from_u64(65536);
+                    let __v_236: G = (__v_235 * __v_120);
+                    let __v_237: G = G::from_u64(16777216);
+                    let __v_238: G = (__v_237 * __v_121);
+                    let __v_239: G = G::from_u64(4294967296);
+                    let __v_240: G = (__v_239 * __v_122);
+                    let __v_241: G = G::from_u64(1099511627776);
+                    let __v_242: G = (__v_241 * __v_123);
+                    let __v_243: G = G::from_u64(281474976710656);
+                    let __v_244: G = (__v_243 * __v_124);
+                    let __v_245: G = G::from_u64(72057594037927936);
+                    let __v_246: G = (__v_245 * __v_125);
+                    let __v_247: G = (__v_244 + __v_246);
+                    let __v_248: G = (__v_242 + __v_247);
+                    let __v_249: G = (__v_240 + __v_248);
+                    let __v_250: G = (__v_238 + __v_249);
+                    let __v_251: G = (__v_236 + __v_250);
+                    let __v_252: G = (__v_234 + __v_251);
+                    let __v_253: G = (__v_118 + __v_252);
+                    let __v_254: G = G::from_u64(256);
+                    let __v_255: G = (__v_254 * __v_127);
+                    let __v_256: G = G::from_u64(65536);
+                    let __v_257: G = (__v_256 * __v_128);
+                    let __v_258: G = G::from_u64(16777216);
+                    let __v_259: G = (__v_258 * __v_129);
+                    let __v_260: G = G::from_u64(4294967296);
+                    let __v_261: G = (__v_260 * __v_130);
+                    let __v_262: G = G::from_u64(1099511627776);
+                    let __v_263: G = (__v_262 * __v_131);
+                    let __v_264: G = G::from_u64(281474976710656);
+                    let __v_265: G = (__v_264 * __v_132);
+                    let __v_266: G = G::from_u64(72057594037927936);
+                    let __v_267: G = (__v_266 * __v_133);
+                    let __v_268: G = (__v_265 + __v_267);
+                    let __v_269: G = (__v_263 + __v_268);
+                    let __v_270: G = (__v_261 + __v_269);
+                    let __v_271: G = (__v_259 + __v_270);
+                    let __v_272: G = (__v_257 + __v_271);
+                    let __v_273: G = (__v_255 + __v_272);
+                    let __v_274: G = (__v_126 + __v_273);
+                    let __v_275: G = G::from_u64(256);
+                    let __v_276: G = (__v_275 * __v_152);
+                    let __v_277: G = G::from_u64(65536);
+                    let __v_278: G = (__v_277 * __v_153);
+                    let __v_279: G = G::from_u64(16777216);
+                    let __v_280: G = (__v_279 * __v_154);
+                    let __v_281: G = G::from_u64(4294967296);
+                    let __v_282: G = (__v_281 * __v_155);
+                    let __v_283: G = G::from_u64(1099511627776);
+                    let __v_284: G = (__v_283 * __v_156);
+                    let __v_285: G = G::from_u64(281474976710656);
+                    let __v_286: G = (__v_285 * __v_157);
+                    let __v_287: G = G::from_u64(72057594037927936);
+                    let __v_288: G = (__v_287 * __v_158);
+                    let __v_289: G = (__v_286 + __v_288);
+                    let __v_290: G = (__v_284 + __v_289);
+                    let __v_291: G = (__v_282 + __v_290);
+                    let __v_292: G = (__v_280 + __v_291);
+                    let __v_293: G = (__v_278 + __v_292);
+                    let __v_294: G = (__v_276 + __v_293);
+                    let __v_295: G = (__v_151 + __v_294);
+                    let __v_296: G = G::from_u64(256);
+                    let __v_297: G = (__v_296 * __v_160);
+                    let __v_298: G = G::from_u64(65536);
+                    let __v_299: G = (__v_298 * __v_161);
+                    let __v_300: G = G::from_u64(16777216);
+                    let __v_301: G = (__v_300 * __v_162);
+                    let __v_302: G = G::from_u64(4294967296);
+                    let __v_303: G = (__v_302 * __v_163);
+                    let __v_304: G = G::from_u64(1099511627776);
+                    let __v_305: G = (__v_304 * __v_164);
+                    let __v_306: G = G::from_u64(281474976710656);
+                    let __v_307: G = (__v_306 * __v_165);
+                    let __v_308: G = G::from_u64(72057594037927936);
+                    let __v_309: G = (__v_308 * __v_166);
+                    let __v_310: G = (__v_307 + __v_309);
+                    let __v_311: G = (__v_305 + __v_310);
+                    let __v_312: G = (__v_303 + __v_311);
+                    let __v_313: G = (__v_301 + __v_312);
+                    let __v_314: G = (__v_299 + __v_313);
+                    let __v_315: G = (__v_297 + __v_314);
+                    let __v_316: G = (__v_159 + __v_315);
+                    let __v_317: G = G::from_u64(256);
+                    let __v_318: G = (__v_317 * __v_174);
+                    let __v_319: G = G::from_u64(65536);
+                    let __v_320: G = (__v_319 * __v_175);
+                    let __v_321: G = G::from_u64(16777216);
+                    let __v_322: G = (__v_321 * __v_176);
+                    let __v_323: G = G::from_u64(4294967296);
+                    let __v_324: G = (__v_323 * __v_177);
+                    let __v_325: G = G::from_u64(1099511627776);
+                    let __v_326: G = (__v_325 * __v_178);
+                    let __v_327: G = G::from_u64(281474976710656);
+                    let __v_328: G = (__v_327 * __v_179);
+                    let __v_329: G = G::from_u64(72057594037927936);
+                    let __v_330: G = (__v_329 * __v_180);
+                    let __v_331: G = (__v_328 + __v_330);
+                    let __v_332: G = (__v_326 + __v_331);
+                    let __v_333: G = (__v_324 + __v_332);
+                    let __v_334: G = (__v_322 + __v_333);
+                    let __v_335: G = (__v_320 + __v_334);
+                    let __v_336: G = (__v_318 + __v_335);
+                    let __v_337: G = (__v_173 + __v_336);
+                    let __v_338: G = G::from_u64(256);
+                    let __v_339: G = (__v_338 * __v_182);
+                    let __v_340: G = G::from_u64(65536);
+                    let __v_341: G = (__v_340 * __v_183);
+                    let __v_342: G = G::from_u64(16777216);
+                    let __v_343: G = (__v_342 * __v_184);
+                    let __v_344: G = G::from_u64(4294967296);
+                    let __v_345: G = (__v_344 * __v_185);
+                    let __v_346: G = G::from_u64(1099511627776);
+                    let __v_347: G = (__v_346 * __v_186);
+                    let __v_348: G = G::from_u64(281474976710656);
+                    let __v_349: G = (__v_348 * __v_187);
+                    let __v_350: G = G::from_u64(72057594037927936);
+                    let __v_351: G = (__v_350 * __v_188);
+                    let __v_352: G = (__v_349 + __v_351);
+                    let __v_353: G = (__v_347 + __v_352);
+                    let __v_354: G = (__v_345 + __v_353);
+                    let __v_355: G = (__v_343 + __v_354);
+                    let __v_356: G = (__v_341 + __v_355);
+                    let __v_357: G = (__v_339 + __v_356);
+                    let __v_358: G = (__v_181 + __v_357);
+                    let __v_359: G = G::from_u64(0);
+                    let __v_360: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_361: G = __r_arr[0];
+                    let __v_362: G = __r_arr[1];
+                    let __v_363: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_364: G = __r_arr[0];
+                    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_365: G = __r_arr[0];
+                    match __v_18.as_canonical_u64() {
+                      _ => {
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_366: G = __r_arr[0];
+                        let __v_367: G = G::from_u64(1);
+                        let __v_368: G = G::from_u64(1);
+                        let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_369];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_33, __v_369]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_370: G = __r_arr[0];
+    break '__mc_1 [__v_370];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_370: G = __mc_out___mc_1[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_31, __v_370]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_371: G = __r_arr[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_35, __v_371]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_372: G = __r_arr[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_34, __v_372]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_373: G = __r_arr[0];
+                        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_189, __v_373]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_374: G = __r_arr[0];
+                        let __v_375: G = G::from_u64(1);
+                        let __v_376: G = G::from_u64(1);
+                        let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_374, __v_377]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_378: G = __r_arr[0];
+                        let __v_379: G = __r_arr[1];
+                        let __v_380: G = __r_arr[2];
+                        let __v_381: G = __r_arr[3];
+                        let __v_382: G = __r_arr[4];
+                        let __v_383: G = __r_arr[5];
+                        let __v_384: G = __r_arr[6];
+                        let __v_385: G = __r_arr[7];
+                        let __v_386: G = __r_arr[8];
+                        let __v_387: G = __r_arr[9];
+                        let __v_388: G = __r_arr[10];
+                        let __v_389: G = __r_arr[11];
+                        let __v_390: G = __r_arr[12];
+                        let __v_391: G = __r_arr[13];
+                        let __v_392: G = __r_arr[14];
+                        let __v_393: G = __r_arr[15];
+                        let __v_394: G = __r_arr[16];
+                        let __v_395: G = __r_arr[17];
+                        let __v_396: G = G::from_u64(256);
+                        let __v_397: G = (__v_396 * __v_379);
+                        let __v_398: G = G::from_u64(65536);
+                        let __v_399: G = (__v_398 * __v_380);
+                        let __v_400: G = G::from_u64(16777216);
+                        let __v_401: G = (__v_400 * __v_381);
+                        let __v_402: G = G::from_u64(4294967296);
+                        let __v_403: G = (__v_402 * __v_382);
+                        let __v_404: G = G::from_u64(1099511627776);
+                        let __v_405: G = (__v_404 * __v_383);
+                        let __v_406: G = G::from_u64(281474976710656);
+                        let __v_407: G = (__v_406 * __v_384);
+                        let __v_408: G = G::from_u64(72057594037927936);
+                        let __v_409: G = (__v_408 * __v_385);
+                        let __v_410: G = (__v_407 + __v_409);
+                        let __v_411: G = (__v_405 + __v_410);
+                        let __v_412: G = (__v_403 + __v_411);
+                        let __v_413: G = (__v_401 + __v_412);
+                        let __v_414: G = (__v_399 + __v_413);
+                        let __v_415: G = (__v_397 + __v_414);
+                        let __v_416: G = (__v_378 + __v_415);
+                        let __v_417: G = G::from_u64(256);
+                        let __v_418: G = (__v_417 * __v_387);
+                        let __v_419: G = G::from_u64(65536);
+                        let __v_420: G = (__v_419 * __v_388);
+                        let __v_421: G = G::from_u64(16777216);
+                        let __v_422: G = (__v_421 * __v_389);
+                        let __v_423: G = G::from_u64(4294967296);
+                        let __v_424: G = (__v_423 * __v_390);
+                        let __v_425: G = G::from_u64(1099511627776);
+                        let __v_426: G = (__v_425 * __v_391);
+                        let __v_427: G = G::from_u64(281474976710656);
+                        let __v_428: G = (__v_427 * __v_392);
+                        let __v_429: G = G::from_u64(72057594037927936);
+                        let __v_430: G = (__v_429 * __v_393);
+                        let __v_431: G = (__v_428 + __v_430);
+                        let __v_432: G = (__v_426 + __v_431);
+                        let __v_433: G = (__v_424 + __v_432);
+                        let __v_434: G = (__v_422 + __v_433);
+                        let __v_435: G = (__v_420 + __v_434);
+                        let __v_436: G = (__v_418 + __v_435);
+                        let __v_437: G = (__v_386 + __v_436);
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_394, __v_18, __v_19, __v_5]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_438: G = __r_arr[0];
+                        let __v_439: G = __r_arr[1];
+                        let __v_440: G = G::from_u64(1);
+                        let __v_441: G = G::from_u64(1);
+                        let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_22, __v_442]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_443: G = __r_arr[0];
+                        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_439, __v_443]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_444: G = __r_arr[0];
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_444, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_445: G = __r_arr[0];
+                        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_446: G = __r_arr[0];
+                        let __v_447: G = __r_arr[1];
+                        let __v_448: G = (__v_366 + __v_0);
+                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_4, __v_448]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_449: G = __r_arr[0];
+                        let __v_450: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_20, __v_21, __v_450, __v_4]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_451: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_452: G = __r_arr[0];
+                        let __v_453: G = G::from_u64(0);
+                        if (__v_1 != __v_453) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_453.as_canonical_u64(), msg: None });
+                        }
+                        let __v_454: G = G::from_u64(0);
+                        if (__v_2 != __v_454) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
+                        }
+                        let __v_455: G = G::from_u64(1);
+                        if (__v_3 != __v_455) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_456: G = __r_arr[0];
+                        let __v_457: G = G::from_u64(1);
+                        if (__v_456 != __v_457) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_458: G = __r_arr[0];
+                        let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_459: G = __r_arr[0];
+                        let __v_460: G = (__v_458 - __v_459);
+                        let __v_461: G = G::from_bool((__v_460 == G::ZERO));
+                        let __v_462: G = G::from_u64(1);
+                        if (__v_461 != __v_462) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_463: G = __r_arr[0];
+                        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_464: G = __r_arr[0];
+                        let __v_465: G = (__v_463 - __v_464);
+                        let __v_466: G = G::from_bool((__v_465 == G::ZERO));
+                        let __v_467: G = G::from_u64(1);
+                        if (__v_466 != __v_467) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_19]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_468: G = __r_arr[0];
+                        let __v_469: G = (__v_468 - __v_366);
+                        let __v_470: G = G::from_bool((__v_469 == G::ZERO));
+                        let __v_471: G = G::from_u64(1);
+                        if (__v_470 != __v_471) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_20]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_472: G = __r_arr[0];
+                        let __v_473: G = G::from_u64(3);
+                        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_32, __v_33]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_474: G = __r_arr[0];
+                        let __v_475: G = (__v_473 + __v_474);
+                        if (__v_472 != __v_475) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_476: G = __r_arr[0];
+                        let __v_477: G = (__v_476 - __v_366);
+                        let __v_478: G = G::from_bool((__v_477 == G::ZERO));
+                        let __v_479: G = G::from_u64(1);
+                        if (__v_478 != __v_479) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None });
+                        }
+                        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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_480: G = __r_arr[0];
+                        let __v_481: G = G::from_u64(1);
+                        if (__v_480 != __v_481) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None });
+                        }
+                        let __v_482: G = G::from_u64(33);
+                        let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                        let __v_484: G = G::from_u64(1);
+                        if (__v_483 != __v_484) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_485: G = __r_arr[0];
+                        let __v_486: G = G::from_u64(1);
+                        if (__v_485 != __v_486) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None });
+                        }
+                        let __v_487: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_488: G = __r_arr[0];
+                        let __ret: [G; OUT_198] = [__v_488];
+                        if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_199: usize = 1;
+const IN_199: usize = 1;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_199], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_199] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_2 - __v_4);
+        let __v_6: G = (__v_2 * __v_5);
+        let __v_7: G = G::from_u64(0);
+        if (__v_6 != __v_7) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        let __ret: [G; OUT_199] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_200: usize = 2;
+const IN_200: usize = 2;
+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_200], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_200] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        match __v_10.as_canonical_u64() {
+          0u64 => {
+            match __v_11.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+                let __ret: [G; OUT_200] = [__v_13];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_13: G = G::from_u64(0);
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+                let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_200] = [__v_15];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+const OUT_201: usize = 1;
+fn aiur_fn_201(
+  inp: [G; IN_201],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_201], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_201] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_8]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+                let __ret: [G; OUT_201] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_8]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_201] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 2;
+fn aiur_fn_202(
+  inp: [G; IN_202],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_202], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_202] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[202].weight(); } record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_203: usize = 2;
+const IN_203: usize = 2;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_203], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_203] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_2]; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_7]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_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_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_203] = [__v_11, __v_9];
+        if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_204: usize = 1;
+const IN_204: usize = 1;
+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_204], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2, __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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_204] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_205: usize = 2;
+const IN_205: usize = 2;
+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_205], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_205] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_12]; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_205] = [__v_16, __v_14];
+        if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+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_206], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                                                                                                    let __ret: [G; OUT_206] = [__v_97, __v_96];
+                                                                                                                                    if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                                                                                                                    return Ok(__ret);
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                  },
+                                                                                                                                }
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
+                                                                                                                              },
+                                                                                                                            }
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
+                                                                                                                          },
+                                                                                                                        }
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
+                                                                                                                      },
+                                                                                                                    }
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
+                                                                                                                  },
+                                                                                                                }
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
+                                                                                                              },
+                                                                                                            }
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
+                                                                                                          },
+                                                                                                        }
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
+                                                                                                      },
+                                                                                                    }
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+                                                                                                  },
+                                                                                                }
+                                                                                              },
+                                                                                              _ => {
+                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
+                                                                                              },
+                                                                                            }
+                                                                                          },
+                                                                                          _ => {
+                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
+                                                                                          },
+                                                                                        }
+                                                                                      },
+                                                                                      _ => {
+                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
+                                                                                      },
+                                                                                    }
+                                                                                  },
+                                                                                  _ => {
+                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
+                                                                                  },
+                                                                                }
+                                                                              },
+                                                                              _ => {
+                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+                                                                              },
+                                                                            }
+                                                                          },
+                                                                          _ => {
+                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
+                                                                          },
+                                                                        }
+                                                                      },
+                                                                      _ => {
+                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
+                                                                      },
+                                                                    }
+                                                                  },
+                                                                  _ => {
+                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
+                                                                  },
+                                                                }
+                                                              },
+                                                              _ => {
+                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
+                                                              },
+                                                            }
+                                                          },
+                                                          _ => {
+                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                                                          },
+                                                        }
+                                                      },
+                                                      _ => {
+                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+                                                      },
+                                                    }
+                                                  },
+                                                  _ => {
+                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_207: usize = 2;
+const IN_207: usize = 2;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_207], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = G::from_u64(0);
+    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_70: G = G::from_u64(0);
+    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_78: G = G::from_u64(0);
+    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_80: G = G::from_u64(0);
+    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = G::from_u64(0);
+    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = G::from_u64(0);
+    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = G::from_u64(0);
+    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_88: G = G::from_u64(0);
+    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_90: G = G::from_u64(0);
+    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_94: G = G::from_u64(0);
+    let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_207] = [__v_97];
+    if !unconstrained { record.virt += record.function_queries[207].weight(); } record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_208: usize = 1;
+const IN_208: usize = 1;
+const OUT_208: usize = 8;
+fn aiur_fn_208(
+  inp: [G; IN_208],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_208], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = G::from_u64(256);
+    let __v_34: G = (__v_33 * __v_2);
+    let __v_35: G = G::from_u64(65536);
+    let __v_36: G = (__v_35 * __v_3);
+    let __v_37: G = G::from_u64(16777216);
+    let __v_38: G = (__v_37 * __v_4);
+    let __v_39: G = (__v_36 + __v_38);
+    let __v_40: G = (__v_34 + __v_39);
+    let __v_41: G = (__v_1 + __v_40);
+    let __v_42: G = G::from_u64(256);
+    let __v_43: G = (__v_42 * __v_6);
+    let __v_44: G = G::from_u64(65536);
+    let __v_45: G = (__v_44 * __v_7);
+    let __v_46: G = G::from_u64(16777216);
+    let __v_47: G = (__v_46 * __v_8);
+    let __v_48: G = (__v_45 + __v_47);
+    let __v_49: G = (__v_43 + __v_48);
+    let __v_50: G = (__v_5 + __v_49);
+    let __v_51: G = G::from_u64(256);
+    let __v_52: G = (__v_51 * __v_10);
+    let __v_53: G = G::from_u64(65536);
+    let __v_54: G = (__v_53 * __v_11);
+    let __v_55: G = G::from_u64(16777216);
+    let __v_56: G = (__v_55 * __v_12);
+    let __v_57: G = (__v_54 + __v_56);
+    let __v_58: G = (__v_52 + __v_57);
+    let __v_59: G = (__v_9 + __v_58);
+    let __v_60: G = G::from_u64(256);
+    let __v_61: G = (__v_60 * __v_14);
+    let __v_62: G = G::from_u64(65536);
+    let __v_63: G = (__v_62 * __v_15);
+    let __v_64: G = G::from_u64(16777216);
+    let __v_65: G = (__v_64 * __v_16);
+    let __v_66: G = (__v_63 + __v_65);
+    let __v_67: G = (__v_61 + __v_66);
+    let __v_68: G = (__v_13 + __v_67);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_69 * __v_18);
+    let __v_71: G = G::from_u64(65536);
+    let __v_72: G = (__v_71 * __v_19);
+    let __v_73: G = G::from_u64(16777216);
+    let __v_74: G = (__v_73 * __v_20);
+    let __v_75: G = (__v_72 + __v_74);
+    let __v_76: G = (__v_70 + __v_75);
+    let __v_77: G = (__v_17 + __v_76);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_78 * __v_22);
+    let __v_80: G = G::from_u64(65536);
+    let __v_81: G = (__v_80 * __v_23);
+    let __v_82: G = G::from_u64(16777216);
+    let __v_83: G = (__v_82 * __v_24);
+    let __v_84: G = (__v_81 + __v_83);
+    let __v_85: G = (__v_79 + __v_84);
+    let __v_86: G = (__v_21 + __v_85);
+    let __v_87: G = G::from_u64(256);
+    let __v_88: G = (__v_87 * __v_26);
+    let __v_89: G = G::from_u64(65536);
+    let __v_90: G = (__v_89 * __v_27);
+    let __v_91: G = G::from_u64(16777216);
+    let __v_92: G = (__v_91 * __v_28);
+    let __v_93: G = (__v_90 + __v_92);
+    let __v_94: G = (__v_88 + __v_93);
+    let __v_95: G = (__v_25 + __v_94);
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_96 * __v_30);
+    let __v_98: G = G::from_u64(65536);
+    let __v_99: G = (__v_98 * __v_31);
+    let __v_100: G = G::from_u64(16777216);
+    let __v_101: G = (__v_100 * __v_32);
+    let __v_102: G = (__v_99 + __v_101);
+    let __v_103: G = (__v_97 + __v_102);
+    let __v_104: G = (__v_29 + __v_103);
+    let __ret: [G; OUT_208] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104];
+    if !unconstrained { record.virt += record.function_queries[208].weight(); } record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+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_209], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_4]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_5]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; 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 { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_209] = [__v_10];
+    if !unconstrained { record.virt += record.function_queries[209].weight(); } record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_210: usize = 1;
+const IN_210: usize = 1;
+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 __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_3]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; 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 { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __ret: [G; OUT_210] = [__v_8];
+    if !unconstrained { record.virt += record.function_queries[210].weight(); } record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_211: usize = 4;
+const IN_211: usize = 4;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_211], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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(256);
+    let __v_5: G = (__v_0 * __v_4);
+    let __v_6: G = (__v_5 + __v_1);
+    let __v_7: G = G::from_u64(256);
+    let __v_8: G = (__v_6 * __v_7);
+    let __v_9: G = (__v_8 + __v_2);
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = (__v_11 + __v_3);
+    let __ret: [G; OUT_211] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[211].weight(); } record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 1;
+fn aiur_fn_212(
+  inp: [G; IN_212],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_212], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = G::from_u64(256);
+    let __v_67: G = (__v_2 * __v_66);
+    let __v_68: G = (__v_67 + __v_3);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_70 + __v_4);
+    let __v_72: G = G::from_u64(256);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_73 + __v_5);
+    let __v_75: G = G::from_u64(256);
+    let __v_76: G = (__v_34 * __v_75);
+    let __v_77: G = (__v_76 + __v_35);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_77 * __v_78);
+    let __v_80: G = (__v_79 + __v_36);
+    let __v_81: G = G::from_u64(256);
+    let __v_82: G = (__v_80 * __v_81);
+    let __v_83: G = (__v_82 + __v_37);
+    let __v_84: G = (__v_74 - __v_83);
+    match __v_84.as_canonical_u64() {
+      0u64 => {
+        let __v_85: G = G::from_u64(256);
+        let __v_86: G = (__v_6 * __v_85);
+        let __v_87: G = (__v_86 + __v_7);
+        let __v_88: G = G::from_u64(256);
+        let __v_89: G = (__v_87 * __v_88);
+        let __v_90: G = (__v_89 + __v_8);
+        let __v_91: G = G::from_u64(256);
+        let __v_92: G = (__v_90 * __v_91);
+        let __v_93: G = (__v_92 + __v_9);
+        let __v_94: G = G::from_u64(256);
+        let __v_95: G = (__v_38 * __v_94);
+        let __v_96: G = (__v_95 + __v_39);
+        let __v_97: G = G::from_u64(256);
+        let __v_98: G = (__v_96 * __v_97);
+        let __v_99: G = (__v_98 + __v_40);
+        let __v_100: G = G::from_u64(256);
+        let __v_101: G = (__v_99 * __v_100);
+        let __v_102: G = (__v_101 + __v_41);
+        let __v_103: G = (__v_93 - __v_102);
+        match __v_103.as_canonical_u64() {
+          0u64 => {
+            let __v_104: G = G::from_u64(256);
+            let __v_105: G = (__v_10 * __v_104);
+            let __v_106: G = (__v_105 + __v_11);
+            let __v_107: G = G::from_u64(256);
+            let __v_108: G = (__v_106 * __v_107);
+            let __v_109: G = (__v_108 + __v_12);
+            let __v_110: G = G::from_u64(256);
+            let __v_111: G = (__v_109 * __v_110);
+            let __v_112: G = (__v_111 + __v_13);
+            let __v_113: G = G::from_u64(256);
+            let __v_114: G = (__v_42 * __v_113);
+            let __v_115: G = (__v_114 + __v_43);
+            let __v_116: G = G::from_u64(256);
+            let __v_117: G = (__v_115 * __v_116);
+            let __v_118: G = (__v_117 + __v_44);
+            let __v_119: G = G::from_u64(256);
+            let __v_120: G = (__v_118 * __v_119);
+            let __v_121: G = (__v_120 + __v_45);
+            let __v_122: G = (__v_112 - __v_121);
+            match __v_122.as_canonical_u64() {
+              0u64 => {
+                let __v_123: G = G::from_u64(256);
+                let __v_124: G = (__v_14 * __v_123);
+                let __v_125: G = (__v_124 + __v_15);
+                let __v_126: G = G::from_u64(256);
+                let __v_127: G = (__v_125 * __v_126);
+                let __v_128: G = (__v_127 + __v_16);
+                let __v_129: G = G::from_u64(256);
+                let __v_130: G = (__v_128 * __v_129);
+                let __v_131: G = (__v_130 + __v_17);
+                let __v_132: G = G::from_u64(256);
+                let __v_133: G = (__v_46 * __v_132);
+                let __v_134: G = (__v_133 + __v_47);
+                let __v_135: G = G::from_u64(256);
+                let __v_136: G = (__v_134 * __v_135);
+                let __v_137: G = (__v_136 + __v_48);
+                let __v_138: G = G::from_u64(256);
+                let __v_139: G = (__v_137 * __v_138);
+                let __v_140: G = (__v_139 + __v_49);
+                let __v_141: G = (__v_131 - __v_140);
+                match __v_141.as_canonical_u64() {
+                  0u64 => {
+                    let __v_142: G = G::from_u64(256);
+                    let __v_143: G = (__v_18 * __v_142);
+                    let __v_144: G = (__v_143 + __v_19);
+                    let __v_145: G = G::from_u64(256);
+                    let __v_146: G = (__v_144 * __v_145);
+                    let __v_147: G = (__v_146 + __v_20);
+                    let __v_148: G = G::from_u64(256);
+                    let __v_149: G = (__v_147 * __v_148);
+                    let __v_150: G = (__v_149 + __v_21);
+                    let __v_151: G = G::from_u64(256);
+                    let __v_152: G = (__v_50 * __v_151);
+                    let __v_153: G = (__v_152 + __v_51);
+                    let __v_154: G = G::from_u64(256);
+                    let __v_155: G = (__v_153 * __v_154);
+                    let __v_156: G = (__v_155 + __v_52);
+                    let __v_157: G = G::from_u64(256);
+                    let __v_158: G = (__v_156 * __v_157);
+                    let __v_159: G = (__v_158 + __v_53);
+                    let __v_160: G = (__v_150 - __v_159);
+                    match __v_160.as_canonical_u64() {
+                      0u64 => {
+                        let __v_161: G = G::from_u64(256);
+                        let __v_162: G = (__v_22 * __v_161);
+                        let __v_163: G = (__v_162 + __v_23);
+                        let __v_164: G = G::from_u64(256);
+                        let __v_165: G = (__v_163 * __v_164);
+                        let __v_166: G = (__v_165 + __v_24);
+                        let __v_167: G = G::from_u64(256);
+                        let __v_168: G = (__v_166 * __v_167);
+                        let __v_169: G = (__v_168 + __v_25);
+                        let __v_170: G = G::from_u64(256);
+                        let __v_171: G = (__v_54 * __v_170);
+                        let __v_172: G = (__v_171 + __v_55);
+                        let __v_173: G = G::from_u64(256);
+                        let __v_174: G = (__v_172 * __v_173);
+                        let __v_175: G = (__v_174 + __v_56);
+                        let __v_176: G = G::from_u64(256);
+                        let __v_177: G = (__v_175 * __v_176);
+                        let __v_178: G = (__v_177 + __v_57);
+                        let __v_179: G = (__v_169 - __v_178);
+                        match __v_179.as_canonical_u64() {
+                          0u64 => {
+                            let __v_180: G = G::from_u64(256);
+                            let __v_181: G = (__v_26 * __v_180);
+                            let __v_182: G = (__v_181 + __v_27);
+                            let __v_183: G = G::from_u64(256);
+                            let __v_184: G = (__v_182 * __v_183);
+                            let __v_185: G = (__v_184 + __v_28);
+                            let __v_186: G = G::from_u64(256);
+                            let __v_187: G = (__v_185 * __v_186);
+                            let __v_188: G = (__v_187 + __v_29);
+                            let __v_189: G = G::from_u64(256);
+                            let __v_190: G = (__v_58 * __v_189);
+                            let __v_191: G = (__v_190 + __v_59);
+                            let __v_192: G = G::from_u64(256);
+                            let __v_193: G = (__v_191 * __v_192);
+                            let __v_194: G = (__v_193 + __v_60);
+                            let __v_195: G = G::from_u64(256);
+                            let __v_196: G = (__v_194 * __v_195);
+                            let __v_197: G = (__v_196 + __v_61);
+                            let __v_198: G = (__v_188 - __v_197);
+                            match __v_198.as_canonical_u64() {
+                              0u64 => {
+                                let __v_199: G = G::from_u64(256);
+                                let __v_200: G = (__v_30 * __v_199);
+                                let __v_201: G = (__v_200 + __v_31);
+                                let __v_202: G = G::from_u64(256);
+                                let __v_203: G = (__v_201 * __v_202);
+                                let __v_204: G = (__v_203 + __v_32);
+                                let __v_205: G = G::from_u64(256);
+                                let __v_206: G = (__v_204 * __v_205);
+                                let __v_207: G = (__v_206 + __v_33);
+                                let __v_208: G = G::from_u64(256);
+                                let __v_209: G = (__v_62 * __v_208);
+                                let __v_210: G = (__v_209 + __v_63);
+                                let __v_211: G = G::from_u64(256);
+                                let __v_212: G = (__v_210 * __v_211);
+                                let __v_213: G = (__v_212 + __v_64);
+                                let __v_214: G = G::from_u64(256);
+                                let __v_215: G = (__v_213 * __v_214);
+                                let __v_216: G = (__v_215 + __v_65);
+                                let __v_217: G = (__v_207 - __v_216);
+                                match __v_217.as_canonical_u64() {
+                                  0u64 => {
+                                    let __v_218: G = G::from_u64(1);
+                                    let __ret: [G; OUT_212] = [__v_218];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_218.as_canonical_u64() {
+                                      1u64 => {
+                                        let __v_219: G = G::from_u64(0);
+                                        let __ret: [G; OUT_212] = [__v_219];
+                                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __v_219: G = G::from_u64(2);
+                                        let __ret: [G; OUT_212] = [__v_219];
+                                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_199.as_canonical_u64() {
+                                  1u64 => {
+                                    let __v_200: G = G::from_u64(0);
+                                    let __ret: [G; OUT_212] = [__v_200];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_200: G = G::from_u64(2);
+                                    let __ret: [G; OUT_212] = [__v_200];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_180.as_canonical_u64() {
+                              1u64 => {
+                                let __v_181: G = G::from_u64(0);
+                                let __ret: [G; OUT_212] = [__v_181];
+                                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __v_181: G = G::from_u64(2);
+                                let __ret: [G; OUT_212] = [__v_181];
+                                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_161.as_canonical_u64() {
+                          1u64 => {
+                            let __v_162: G = G::from_u64(0);
+                            let __ret: [G; OUT_212] = [__v_162];
+                            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_162: G = G::from_u64(2);
+                            let __ret: [G; OUT_212] = [__v_162];
+                            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_142.as_canonical_u64() {
+                      1u64 => {
+                        let __v_143: G = G::from_u64(0);
+                        let __ret: [G; OUT_212] = [__v_143];
+                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_143: G = G::from_u64(2);
+                        let __ret: [G; OUT_212] = [__v_143];
+                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_123.as_canonical_u64() {
+                  1u64 => {
+                    let __v_124: G = G::from_u64(0);
+                    let __ret: [G; OUT_212] = [__v_124];
+                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_124: G = G::from_u64(2);
+                    let __ret: [G; OUT_212] = [__v_124];
+                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+          _ => {
+            let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_104.as_canonical_u64() {
+              1u64 => {
+                let __v_105: G = G::from_u64(0);
+                let __ret: [G; OUT_212] = [__v_105];
+                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_105: G = G::from_u64(2);
+                let __ret: [G; OUT_212] = [__v_105];
+                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_85.as_canonical_u64() {
+          1u64 => {
+            let __v_86: G = G::from_u64(0);
+            let __ret: [G; OUT_212] = [__v_86];
+            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_86: G = G::from_u64(2);
+            let __ret: [G; OUT_212] = [__v_86];
+            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_213: usize = 1;
+const IN_213: usize = 1;
+const OUT_213: usize = 0;
+fn aiur_fn_213(
+  inp: [G; IN_213],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_213], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __ret: [G; OUT_213] = [];
+        if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_213] = [];
+            if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_2, __v_5]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __v_8: G = G::from_u64(0);
+            if (__v_7 != __v_8) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: tree leaves are not strictly sorted".to_string()) });
+            }
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3]; 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 { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_213] = [];
+            if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 1;
+const IN_214: usize = 1;
+const OUT_214: usize = 2;
+fn aiur_fn_214(
+  inp: [G; IN_214],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_214], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_214] = [__v_9, __v_4];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_214] = [__v_5, __v_2];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3, __v_5]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_214] = [__v_7, __v_6];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_215: usize = 1;
+const IN_215: usize = 1;
+const OUT_215: usize = 1;
+fn aiur_fn_215(
+  inp: [G; IN_215],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_215], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_215] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2]; 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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3]; 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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_215] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_216: usize = 1;
+const IN_216: usize = 1;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_216], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_216] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __v_24: G = G::from_u64(0);
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            let __v_36: G = G::from_u64(0);
+            let __v_37: G = G::from_u64(0);
+            let __v_38: G = G::from_u64(0);
+            let __v_39: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_40: G = G::from_u64(0);
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_39]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+            let __v_42: G = G::from_u64(1);
+            let __v_43: G = G::from_u64(1);
+            let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_216] = [__v_45];
+            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_5]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6]; 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 { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_216] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 1;
+fn aiur_fn_217(
+  inp: [G; IN_217],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_217], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_217] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; 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 { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7]; 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 { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_217] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_218: usize = 1;
+const IN_218: usize = 1;
+const OUT_218: usize = 1;
+fn aiur_fn_218(
+  inp: [G; IN_218],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_218], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; 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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; 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 { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __ret: [G; OUT_218] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_219], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = G::from_u64(5);
+    let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(5);
+    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_77] = { let __args: [G; IN_77] = [__v_37]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_40]; 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 { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } 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] = [__v_40]; 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 { let __r = record.function_queries[218].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+    let __v_43: G = G::from_u64(226);
+    if (__v_38 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("aggr: tree has the wrong Ixon tag".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    if (__v_44 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) });
+    }
+    if (__v_45 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) });
+    }
+    if (__v_46 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) });
+    }
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_40]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __v_50: G = G::from_u64(0);
+    if (__v_49 != __v_50) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("aggr: a present tree must contain at least one leaf".to_string()) });
+    }
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = G::from_u64(1);
+    if (__v_51 != __v_52) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("aggr: tree leaves do not reproduce the canonical root".to_string()) });
+    }
+    let __ret: [G; OUT_219] = [__v_40];
+    if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_220: usize = 2;
+const IN_220: usize = 2;
+const OUT_220: usize = 1;
+fn aiur_fn_220(
+  inp: [G; IN_220],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_220], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_220] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __ret: [G; OUT_220] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+const OUT_221: usize = 0;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_221] = [];
+            if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_9: G = G::from_u64(1);
+            if (__v_8 != __v_9) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: set element mismatch".to_string()) });
+            }
+            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_221] = [];
+            if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_222: usize = 3;
+const IN_222: usize = 3;
+const OUT_222: usize = 0;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+        if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_2]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+            if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __v_7]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("aggr: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("aggr: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_8, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("aggr: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_8, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_223: usize = 2;
+const IN_223: usize = 2;
+const OUT_223: usize = 4;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_223] = [__v_8, __v_9, __v_9, __v_9];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_223] = [__v_8, __v_6, __v_0, __v_7];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_223] = [__v_8, __v_3, __v_4, __v_1];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_6]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_3, __v_4, __v_1];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_3, __v_4, __v_7];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_6, __v_0, __v_7];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_224: usize = 2;
+const IN_224: usize = 2;
+const OUT_224: usize = 2;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_224] = [__v_5, __v_1];
+        if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_0]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_4]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_224] = [__v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_224] = [__v_6, __v_4];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_224] = [__v_6, __v_1];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_225: usize = 4;
+const IN_225: usize = 4;
+const OUT_225: usize = 0;
+fn aiur_fn_225(
+  inp: [G; IN_225],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_225], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        if (__v_8 != __v_11) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) });
+        }
+        if (__v_9 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) });
+        }
+        if (__v_10 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) });
+        }
+        let __ret: [G; OUT_225] = [];
+        if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_2]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_7, __v_9, __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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_225] = [];
+            if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                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("aggr: outstanding assumption mismatch".to_string()) });
+                }
+                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_7, __v_9, __v_12]; 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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_225] = [];
+                if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_226: usize = 3;
+const IN_226: usize = 3;
+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_226], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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_226] = [__v_0, __v_2];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_0]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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];
+    break '__mc_0 [__v_7];
+  },
+  _ => {
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_5]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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];
+    break '__mc_0 [__v_7];
+  },
+}
+ };
+        let __v_7: G = __mc_out___mc_0[0];
+        let __v_8: G = G::from_u64(2);
+        let __v_9: G = if unconstrained { Bytes2::less_than(&__v_3, &__v_8) } else { bytes2_less_than_value(__v_3, __v_8, record) };
+        let __v_10: G = G::from_u64(1);
+        if (__v_9 != __v_10) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("aggr structural: path side must be 0 or 1".to_string()) });
+        }
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_12, __v_6]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_226] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_227: usize = 2;
+const IN_227: usize = 2;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_227], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(6);
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    let __v_13: G = __loaded[10];
+    let __v_14: G = __loaded[11];
+    let __v_15: G = __loaded[12];
+    let __v_16: G = __loaded[13];
+    let __v_17: G = __loaded[14];
+    let __v_18: G = __loaded[15];
+    let __v_19: G = __loaded[16];
+    let __v_20: G = __loaded[17];
+    let __v_21: G = __loaded[18];
+    let __v_22: G = __loaded[19];
+    let __v_23: G = __loaded[20];
+    let __v_24: G = __loaded[21];
+    let __v_25: G = __loaded[22];
+    let __v_26: G = __loaded[23];
+    let __v_27: G = __loaded[24];
+    let __v_28: G = __loaded[25];
+    let __v_29: G = __loaded[26];
+    let __v_30: G = __loaded[27];
+    let __v_31: G = __loaded[28];
+    let __v_32: G = __loaded[29];
+    let __v_33: G = __loaded[30];
+    let __v_34: G = __loaded[31];
+    let __io_pair: (G, G) = { let __key: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __info = io_buffer.get_info(__v_2, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_35: G = __io_pair.0;
+    let __v_36: G = __io_pair.1;
+    let __v_37: G = G::from_u64(6);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; 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_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = G::from_u64(2);
+    let __v_42: G = if unconstrained { Bytes2::less_than(&__v_39, &__v_41) } else { bytes2_less_than_value(__v_39, __v_41, record) };
+    let __v_43: G = G::from_u64(1);
+    if (__v_42 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("aggr structural: discharge choice must be 0 or 1".to_string()) });
+    }
+    match __v_39.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_44: G = __loaded[0];
+        let __v_45: G = __loaded[1];
+        let __v_46: G = __loaded[2];
+        let __v_47: G = G::from_u64(1);
+        let __v_48: G = G::from_u64(1);
+        if (__v_44 != __v_47) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) });
+        }
+        if (__v_45 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) });
+        }
+        if (__v_46 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr structural: carried choice has trailing bytes".to_string()) });
+        }
+        let __v_49: G = G::from_u64(0);
+        let __ret: [G; OUT_227] = [__v_49];
+        if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0]; 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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_46, __v_44, __v_45]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
+        let __v_48: G = __r_arr[1];
+        let __v_49: G = G::from_u64(65);
+        let __v_50: G = if unconstrained { Bytes2::less_than(&__v_44, &__v_49) } else { bytes2_less_than_value(__v_44, __v_49, record) };
+        let __v_51: G = G::from_u64(1);
+        if (__v_50 != __v_51) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("aggr structural: Merkle path exceeds 64 steps".to_string()) });
+        }
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_52: G = __loaded[0];
+        let __v_53: G = __loaded[1];
+        let __v_54: G = __loaded[2];
+        let __v_55: G = G::from_u64(1);
+        let __v_56: G = G::from_u64(1);
+        if (__v_52 != __v_55) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) });
+        }
+        if (__v_53 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) });
+        }
+        if (__v_54 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) });
+        }
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = G::from_u64(1);
+        if (__v_57 != __v_58) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("aggr structural: assumption path does not reach subject root".to_string()) });
+        }
+        let __v_59: G = G::from_u64(1);
+        let __ret: [G; OUT_227] = [__v_59];
+        if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_228: usize = 4;
+const IN_228: usize = 4;
+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_228], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        if (__v_8 != __v_11) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) });
+        }
+        if (__v_9 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) });
+        }
+        if (__v_10 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) });
+        }
+        let __ret: [G; OUT_228] = [];
+        if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_2]; 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 { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_7, __v_2, __v_3]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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] = [];
+            if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_13: G = G::from_u64(1);
+                if (__v_12 != __v_13) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr structural: outstanding assumption mismatch".to_string()) });
+                }
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_7, __v_2, __v_11]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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] = [];
+                if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_229: usize = 1;
+const IN_229: usize = 1;
+const OUT_229: usize = 3;
+fn aiur_fn_229(
+  inp: [G; IN_229],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_229], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_229] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_229] = [__v_5, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_230: usize = 1;
+const IN_230: usize = 1;
+const OUT_230: usize = 3;
+fn aiur_fn_230(
+  inp: [G; IN_230],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_230], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4]; 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 { let __r = record.function_queries[229].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __v_7: G = __r_arr[2];
+    let __v_8: G = G::from_u64(229);
+    if (__v_1 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: claim is not CheckEnv".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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()) });
+    }
+    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_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()) });
+    }
+    let __ret: [G; OUT_230] = [__v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_231: usize = 8;
+const IN_231: usize = 8;
+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_231], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(4);
+    let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_9: G = __io_pair.0;
+    let __v_10: G = __io_pair.1;
+    let __v_11: G = G::from_u64(4);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; 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_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(103);
+    let __v_14: G = G::from_u64(230);
+    let __v_15: G = G::from_u64(9);
+    let __v_16: G = G::from_u64(106);
+    let __v_17: G = G::from_u64(133);
+    let __v_18: G = G::from_u64(174);
+    let __v_19: G = G::from_u64(103);
+    let __v_20: G = G::from_u64(187);
+    let __v_21: G = G::from_u64(114);
+    let __v_22: G = G::from_u64(243);
+    let __v_23: G = G::from_u64(110);
+    let __v_24: G = G::from_u64(60);
+    let __v_25: G = G::from_u64(58);
+    let __v_26: G = G::from_u64(245);
+    let __v_27: G = G::from_u64(79);
+    let __v_28: G = G::from_u64(165);
+    let __v_29: G = G::from_u64(127);
+    let __v_30: G = G::from_u64(82);
+    let __v_31: G = G::from_u64(14);
+    let __v_32: G = G::from_u64(81);
+    let __v_33: G = G::from_u64(140);
+    let __v_34: G = G::from_u64(104);
+    let __v_35: G = G::from_u64(5);
+    let __v_36: G = G::from_u64(155);
+    let __v_37: G = G::from_u64(171);
+    let __v_38: G = G::from_u64(217);
+    let __v_39: G = G::from_u64(131);
+    let __v_40: G = G::from_u64(31);
+    let __v_41: G = G::from_u64(25);
+    let __v_42: G = G::from_u64(205);
+    let __v_43: G = G::from_u64(224);
+    let __v_44: G = G::from_u64(91);
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = G::from_u64(0);
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = G::from_u64(0);
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = G::from_u64(0);
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = G::from_u64(0);
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_59: 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_60: G = G::from_u64(1);
+    let __v_61: G = G::from_u64(1);
+    let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+    let __v_65: G = __r_arr[1];
+    let __v_66: G = __r_arr[2];
+    let __v_67: G = __r_arr[3];
+    let __v_68: G = __r_arr[4];
+    let __v_69: G = __r_arr[5];
+    let __v_70: G = __r_arr[6];
+    let __v_71: G = __r_arr[7];
+    let __v_72: G = __r_arr[8];
+    let __v_73: G = __r_arr[9];
+    let __v_74: G = __r_arr[10];
+    let __v_75: G = __r_arr[11];
+    let __v_76: G = __r_arr[12];
+    let __v_77: G = __r_arr[13];
+    let __v_78: G = __r_arr[14];
+    let __v_79: G = __r_arr[15];
+    let __v_80: G = __r_arr[16];
+    let __v_81: G = __r_arr[17];
+    let __v_82: G = __r_arr[18];
+    let __v_83: G = __r_arr[19];
+    let __v_84: G = __r_arr[20];
+    let __v_85: G = __r_arr[21];
+    let __v_86: G = __r_arr[22];
+    let __v_87: G = __r_arr[23];
+    let __v_88: G = __r_arr[24];
+    let __v_89: G = __r_arr[25];
+    let __v_90: G = __r_arr[26];
+    let __v_91: G = __r_arr[27];
+    let __v_92: G = __r_arr[28];
+    let __v_93: G = __r_arr[29];
+    let __v_94: G = __r_arr[30];
+    let __v_95: G = __r_arr[31];
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_96 * __v_65);
+    let __v_98: G = G::from_u64(65536);
+    let __v_99: G = (__v_98 * __v_66);
+    let __v_100: G = G::from_u64(16777216);
+    let __v_101: G = (__v_100 * __v_67);
+    let __v_102: G = (__v_99 + __v_101);
+    let __v_103: G = (__v_97 + __v_102);
+    let __v_104: G = (__v_64 + __v_103);
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_69);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_70);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_71);
+    let __v_111: G = (__v_108 + __v_110);
+    let __v_112: G = (__v_106 + __v_111);
+    let __v_113: G = (__v_68 + __v_112);
+    let __v_114: G = G::from_u64(256);
+    let __v_115: G = (__v_114 * __v_73);
+    let __v_116: G = G::from_u64(65536);
+    let __v_117: G = (__v_116 * __v_74);
+    let __v_118: G = G::from_u64(16777216);
+    let __v_119: G = (__v_118 * __v_75);
+    let __v_120: G = (__v_117 + __v_119);
+    let __v_121: G = (__v_115 + __v_120);
+    let __v_122: G = (__v_72 + __v_121);
+    let __v_123: G = G::from_u64(256);
+    let __v_124: G = (__v_123 * __v_77);
+    let __v_125: G = G::from_u64(65536);
+    let __v_126: G = (__v_125 * __v_78);
+    let __v_127: G = G::from_u64(16777216);
+    let __v_128: G = (__v_127 * __v_79);
+    let __v_129: G = (__v_126 + __v_128);
+    let __v_130: G = (__v_124 + __v_129);
+    let __v_131: G = (__v_76 + __v_130);
+    let __v_132: G = G::from_u64(256);
+    let __v_133: G = (__v_132 * __v_81);
+    let __v_134: G = G::from_u64(65536);
+    let __v_135: G = (__v_134 * __v_82);
+    let __v_136: G = G::from_u64(16777216);
+    let __v_137: G = (__v_136 * __v_83);
+    let __v_138: G = (__v_135 + __v_137);
+    let __v_139: G = (__v_133 + __v_138);
+    let __v_140: G = (__v_80 + __v_139);
+    let __v_141: G = G::from_u64(256);
+    let __v_142: G = (__v_141 * __v_85);
+    let __v_143: G = G::from_u64(65536);
+    let __v_144: G = (__v_143 * __v_86);
+    let __v_145: G = G::from_u64(16777216);
+    let __v_146: G = (__v_145 * __v_87);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_84 + __v_148);
+    let __v_150: G = G::from_u64(256);
+    let __v_151: G = (__v_150 * __v_89);
+    let __v_152: G = G::from_u64(65536);
+    let __v_153: G = (__v_152 * __v_90);
+    let __v_154: G = G::from_u64(16777216);
+    let __v_155: G = (__v_154 * __v_91);
+    let __v_156: G = (__v_153 + __v_155);
+    let __v_157: G = (__v_151 + __v_156);
+    let __v_158: G = (__v_88 + __v_157);
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_93);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_94);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_95);
+    let __v_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_160 + __v_165);
+    let __v_167: G = (__v_92 + __v_166);
+    if (__v_104 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_113 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_113.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_122 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_131 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_140 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_149 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_158 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_167 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) });
+    }
+    let __ret: [G; OUT_231] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_232: usize = 2;
+const IN_232: usize = 2;
+const OUT_232: usize = 1;
+fn aiur_fn_232(
+  inp: [G; IN_232],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_232], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; 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 { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_10 * __v_3);
+    let __v_12: G = G::from_u64(65536);
+    let __v_13: G = (__v_12 * __v_4);
+    let __v_14: G = G::from_u64(16777216);
+    let __v_15: G = (__v_14 * __v_5);
+    let __v_16: G = G::from_u64(4294967296);
+    let __v_17: G = (__v_16 * __v_6);
+    let __v_18: G = G::from_u64(1099511627776);
+    let __v_19: G = (__v_18 * __v_7);
+    let __v_20: G = G::from_u64(281474976710656);
+    let __v_21: G = (__v_20 * __v_8);
+    let __v_22: G = G::from_u64(72057594037927936);
+    let __v_23: G = (__v_22 * __v_9);
+    let __v_24: G = (__v_21 + __v_23);
+    let __v_25: G = (__v_19 + __v_24);
+    let __v_26: G = (__v_17 + __v_25);
+    let __v_27: G = (__v_15 + __v_26);
+    let __v_28: G = (__v_13 + __v_27);
+    let __v_29: G = (__v_11 + __v_28);
+    let __v_30: G = (__v_2 + __v_29);
+    let __ret: [G; OUT_232] = [__v_30];
+    if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_233: usize = 2;
+const IN_233: usize = 2;
+const OUT_233: usize = 8;
+fn aiur_fn_233(
+  inp: [G; IN_233],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_233], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_1 + __v_3);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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 = G::from_u64(2);
+    let __v_7: G = (__v_1 + __v_6);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_7]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = G::from_u64(3);
+    let __v_10: G = (__v_1 + __v_9);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_10]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(4);
+    let __v_13: G = (__v_1 + __v_12);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_13]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __v_15: G = G::from_u64(5);
+    let __v_16: G = (__v_1 + __v_15);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_16]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+    let __v_18: G = G::from_u64(6);
+    let __v_19: G = (__v_1 + __v_18);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_19]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+    let __v_21: G = G::from_u64(7);
+    let __v_22: G = (__v_1 + __v_21);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_22]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+    let __ret: [G; OUT_233] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23];
+    if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_234: usize = 16;
+const IN_234: usize = 16;
+const OUT_234: usize = 0;
+fn aiur_fn_234(
+  inp: [G; IN_234],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_234], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    if (__v_0 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    if (__v_1 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
+    }
+    if (__v_2 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
+    }
+    if (__v_3 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+    }
+    if (__v_4 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    }
+    if (__v_5 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
+    }
+    if (__v_6 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    }
+    if (__v_7 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_234] = [];
+    if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_235: usize = 1;
+const IN_235: usize = 1;
+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_235], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        if (__v_4 != __v_7) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) });
+        }
+        if (__v_5 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) });
+        }
+        if (__v_6 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) });
+        }
+        let __ret: [G; OUT_235] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[235].weight(); } record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_236: usize = 17;
+const IN_236: usize = 17;
+const OUT_236: usize = 12;
+fn aiur_fn_236(
+  inp: [G; IN_236],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_236], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = G::from_u64(1);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_17, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_18: G = __io_pair.0;
+    let __v_19: G = __io_pair.1;
+    let __v_20: G = G::from_u64(1);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; 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_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(103);
+    let __v_23: G = G::from_u64(230);
+    let __v_24: G = G::from_u64(9);
+    let __v_25: G = G::from_u64(106);
+    let __v_26: G = G::from_u64(133);
+    let __v_27: G = G::from_u64(174);
+    let __v_28: G = G::from_u64(103);
+    let __v_29: G = G::from_u64(187);
+    let __v_30: G = G::from_u64(114);
+    let __v_31: G = G::from_u64(243);
+    let __v_32: G = G::from_u64(110);
+    let __v_33: G = G::from_u64(60);
+    let __v_34: G = G::from_u64(58);
+    let __v_35: G = G::from_u64(245);
+    let __v_36: G = G::from_u64(79);
+    let __v_37: G = G::from_u64(165);
+    let __v_38: G = G::from_u64(127);
+    let __v_39: G = G::from_u64(82);
+    let __v_40: G = G::from_u64(14);
+    let __v_41: G = G::from_u64(81);
+    let __v_42: G = G::from_u64(140);
+    let __v_43: G = G::from_u64(104);
+    let __v_44: G = G::from_u64(5);
+    let __v_45: G = G::from_u64(155);
+    let __v_46: G = G::from_u64(171);
+    let __v_47: G = G::from_u64(217);
+    let __v_48: G = G::from_u64(131);
+    let __v_49: G = G::from_u64(31);
+    let __v_50: G = G::from_u64(25);
+    let __v_51: G = G::from_u64(205);
+    let __v_52: G = G::from_u64(224);
+    let __v_53: G = G::from_u64(91);
+    let __v_54: G = G::from_u64(1);
+    let __v_55: G = G::from_u64(1);
+    let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = G::from_u64(0);
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = G::from_u64(1);
+    let __v_70: G = G::from_u64(1);
+    let __v_71: G = { let __values: [G; 34] = [__v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    let __v_75: G = __r_arr[2];
+    let __v_76: G = __r_arr[3];
+    let __v_77: G = __r_arr[4];
+    let __v_78: G = __r_arr[5];
+    let __v_79: G = __r_arr[6];
+    let __v_80: G = __r_arr[7];
+    let __v_81: G = __r_arr[8];
+    let __v_82: G = __r_arr[9];
+    let __v_83: G = __r_arr[10];
+    let __v_84: G = __r_arr[11];
+    let __v_85: G = __r_arr[12];
+    let __v_86: G = __r_arr[13];
+    let __v_87: G = __r_arr[14];
+    let __v_88: G = __r_arr[15];
+    let __v_89: G = __r_arr[16];
+    let __v_90: G = __r_arr[17];
+    let __v_91: G = __r_arr[18];
+    let __v_92: G = __r_arr[19];
+    let __v_93: G = __r_arr[20];
+    let __v_94: G = __r_arr[21];
+    let __v_95: G = __r_arr[22];
+    let __v_96: G = __r_arr[23];
+    let __v_97: G = __r_arr[24];
+    let __v_98: G = __r_arr[25];
+    let __v_99: G = __r_arr[26];
+    let __v_100: G = __r_arr[27];
+    let __v_101: G = __r_arr[28];
+    let __v_102: G = __r_arr[29];
+    let __v_103: G = __r_arr[30];
+    let __v_104: G = __r_arr[31];
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_74);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_75);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_76);
+    let __v_111: G = (__v_108 + __v_110);
+    let __v_112: G = (__v_106 + __v_111);
+    let __v_113: G = (__v_73 + __v_112);
+    let __v_114: G = G::from_u64(256);
+    let __v_115: G = (__v_114 * __v_78);
+    let __v_116: G = G::from_u64(65536);
+    let __v_117: G = (__v_116 * __v_79);
+    let __v_118: G = G::from_u64(16777216);
+    let __v_119: G = (__v_118 * __v_80);
+    let __v_120: G = (__v_117 + __v_119);
+    let __v_121: G = (__v_115 + __v_120);
+    let __v_122: G = (__v_77 + __v_121);
+    let __v_123: G = G::from_u64(256);
+    let __v_124: G = (__v_123 * __v_82);
+    let __v_125: G = G::from_u64(65536);
+    let __v_126: G = (__v_125 * __v_83);
+    let __v_127: G = G::from_u64(16777216);
+    let __v_128: G = (__v_127 * __v_84);
+    let __v_129: G = (__v_126 + __v_128);
+    let __v_130: G = (__v_124 + __v_129);
+    let __v_131: G = (__v_81 + __v_130);
+    let __v_132: G = G::from_u64(256);
+    let __v_133: G = (__v_132 * __v_86);
+    let __v_134: G = G::from_u64(65536);
+    let __v_135: G = (__v_134 * __v_87);
+    let __v_136: G = G::from_u64(16777216);
+    let __v_137: G = (__v_136 * __v_88);
+    let __v_138: G = (__v_135 + __v_137);
+    let __v_139: G = (__v_133 + __v_138);
+    let __v_140: G = (__v_85 + __v_139);
+    let __v_141: G = G::from_u64(256);
+    let __v_142: G = (__v_141 * __v_90);
+    let __v_143: G = G::from_u64(65536);
+    let __v_144: G = (__v_143 * __v_91);
+    let __v_145: G = G::from_u64(16777216);
+    let __v_146: G = (__v_145 * __v_92);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_89 + __v_148);
+    let __v_150: G = G::from_u64(256);
+    let __v_151: G = (__v_150 * __v_94);
+    let __v_152: G = G::from_u64(65536);
+    let __v_153: G = (__v_152 * __v_95);
+    let __v_154: G = G::from_u64(16777216);
+    let __v_155: G = (__v_154 * __v_96);
+    let __v_156: G = (__v_153 + __v_155);
+    let __v_157: G = (__v_151 + __v_156);
+    let __v_158: G = (__v_93 + __v_157);
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_98);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_99);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_100);
+    let __v_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_160 + __v_165);
+    let __v_167: G = (__v_97 + __v_166);
+    let __v_168: G = G::from_u64(256);
+    let __v_169: G = (__v_168 * __v_102);
+    let __v_170: G = G::from_u64(65536);
+    let __v_171: G = (__v_170 * __v_103);
+    let __v_172: G = G::from_u64(16777216);
+    let __v_173: G = (__v_172 * __v_104);
+    let __v_174: G = (__v_171 + __v_173);
+    let __v_175: G = (__v_169 + __v_174);
+    let __v_176: G = (__v_101 + __v_175);
+    let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_0.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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)? } };
+    break '__mc_0 [];
+  },
+  _ => {
+    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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)? } };
+    break '__mc_0 [];
+  },
+}
+ };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_21]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_177: G = __r_arr[0];
+    let __v_178: G = __r_arr[1];
+    let __v_179: G = __r_arr[2];
+    let __v_180: G = __r_arr[3];
+    let __v_181: G = __r_arr[4];
+    let __v_182: G = __r_arr[5];
+    let __v_183: G = __r_arr[6];
+    let __v_184: G = __r_arr[7];
+    let __v_185: G = __r_arr[8];
+    let __v_186: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_186]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_187: G = __r_arr[0];
+    let __v_188: G = __r_arr[1];
+    let __v_189: G = __r_arr[2];
+    let __v_190: G = __r_arr[3];
+    let __v_191: G = __r_arr[4];
+    let __v_192: G = __r_arr[5];
+    let __v_193: G = __r_arr[6];
+    let __v_194: G = __r_arr[7];
+    let __v_195: G = __r_arr[8];
+    let __v_196: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_196]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_197: G = __r_arr[0];
+    let __v_198: G = __r_arr[1];
+    let __v_199: G = __r_arr[2];
+    let __v_200: G = __r_arr[3];
+    let __v_201: G = __r_arr[4];
+    let __v_202: G = __r_arr[5];
+    let __v_203: G = __r_arr[6];
+    let __v_204: G = __r_arr[7];
+    let __v_205: G = __r_arr[8];
+    let __v_206: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_206]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_207: G = __r_arr[0];
+    let __v_208: G = __r_arr[1];
+    let __v_209: G = __r_arr[2];
+    let __v_210: G = __r_arr[3];
+    let __v_211: G = __r_arr[4];
+    let __v_212: G = __r_arr[5];
+    let __v_213: G = __r_arr[6];
+    let __v_214: G = __r_arr[7];
+    let __v_215: G = __r_arr[8];
+    let __v_216: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_216]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_217: G = __r_arr[0];
+    let __v_218: G = __r_arr[1];
+    let __v_219: G = __r_arr[2];
+    let __v_220: G = __r_arr[3];
+    let __v_221: G = __r_arr[4];
+    let __v_222: G = __r_arr[5];
+    let __v_223: G = __r_arr[6];
+    let __v_224: G = __r_arr[7];
+    let __v_225: G = __r_arr[8];
+    let __v_226: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_226]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_227: G = __r_arr[0];
+    let __v_228: G = __r_arr[1];
+    let __v_229: G = __r_arr[2];
+    let __v_230: G = __r_arr[3];
+    let __v_231: G = __r_arr[4];
+    let __v_232: G = __r_arr[5];
+    let __v_233: G = __r_arr[6];
+    let __v_234: G = __r_arr[7];
+    let __v_235: G = __r_arr[8];
+    let __v_236: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_236]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_237: G = __r_arr[0];
+    let __v_238: G = __r_arr[1];
+    let __v_239: G = __r_arr[2];
+    let __v_240: G = __r_arr[3];
+    let __v_241: G = __r_arr[4];
+    let __v_242: G = __r_arr[5];
+    let __v_243: G = __r_arr[6];
+    let __v_244: G = __r_arr[7];
+    let __v_245: G = __r_arr[8];
+    let __v_246: G = __r_arr[9];
+    let __v_247: G = G::from_u64(0);
+    let __v_248: G = G::from_u64(0);
+    let __v_249: G = G::from_u64(0);
+    let __v_250: G = G::from_u64(0);
+    let __v_251: G = G::from_u64(0);
+    let __v_252: G = G::from_u64(0);
+    let __v_253: G = G::from_u64(0);
+    let __v_254: G = G::from_u64(1);
+    let __v_255: G = G::from_u64(1);
+    let __v_256: G = { let __values: [G; 10] = [__v_254, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_257: G = { let __values: [G; 10] = [__v_253, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_256]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_258: G = { let __values: [G; 10] = [__v_252, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_259: G = { let __values: [G; 10] = [__v_251, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_258]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_260: G = { let __values: [G; 10] = [__v_250, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_259]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_261: G = { let __values: [G; 10] = [__v_249, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_260]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_262: G = { let __values: [G; 10] = [__v_248, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_261]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_263: G = { let __values: [G; 10] = [__v_247, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_262]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_246]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_264: G = __r_arr[0];
+    let __v_265: G = __r_arr[1];
+    let __v_266: G = __r_arr[2];
+    let __v_267: G = __r_arr[3];
+    let __v_268: G = __r_arr[4];
+    let __v_269: G = __r_arr[5];
+    let __v_270: G = __r_arr[6];
+    let __v_271: G = __r_arr[7];
+    let __v_272: G = __r_arr[8];
+    let __v_273: G = __r_arr[9];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_273, __v_264]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_274: G = __r_arr[0];
+    let __v_275: G = __r_arr[1];
+    let __v_276: G = __r_arr[2];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_276]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_277: G = __r_arr[0];
+    let __v_278: G = __r_arr[1];
+    let __v_279: G = __r_arr[2];
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_279, __v_264]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_280: G = __r_arr[0];
+    let __v_281: G = __r_arr[1];
+    let __v_282: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_282.as_canonical_u64().to_le_bytes();
+    let __v_283: G = G::from_u8(__gb[0]);
+    let __v_284: G = G::from_u8(__gb[1]);
+    let __v_285: G = G::from_u8(__gb[2]);
+    let __v_286: G = G::from_u8(__gb[3]);
+    let __v_287: G = G::from_u8(__gb[4]);
+    let __v_288: G = G::from_u8(__gb[5]);
+    let __v_289: G = G::from_u8(__gb[6]);
+    let __v_290: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_283; let __vj = __v_284; 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_285; let __vj = __v_286; 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_287; let __vj = __v_288; 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_289; let __vj = __v_290; 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_291: G = G::from_u64(1020);
+    let __v_292: G = (__v_290 - __v_291);
+    let __v_293: G = (__v_289 + __v_292);
+    let __v_294: G = (__v_288 + __v_293);
+    let __v_295: G = (__v_287 + __v_294);
+    let __v_296: G = G::from_bool((__v_295 == G::ZERO));
+    let __v_297: G = (__v_285 + __v_286);
+    let __v_298: G = (__v_284 + __v_297);
+    let __v_299: G = (__v_283 + __v_298);
+    let __v_300: G = G::from_bool((__v_299 == G::ZERO));
+    let __v_301: G = G::from_u64(256);
+    let __v_302: G = (__v_301 * __v_284);
+    let __v_303: G = G::from_u64(65536);
+    let __v_304: G = (__v_303 * __v_285);
+    let __v_305: G = G::from_u64(16777216);
+    let __v_306: G = (__v_305 * __v_286);
+    let __v_307: G = G::from_u64(4294967296);
+    let __v_308: G = (__v_307 * __v_287);
+    let __v_309: G = G::from_u64(1099511627776);
+    let __v_310: G = (__v_309 * __v_288);
+    let __v_311: G = G::from_u64(281474976710656);
+    let __v_312: G = (__v_311 * __v_289);
+    let __v_313: G = G::from_u64(72057594037927936);
+    let __v_314: G = (__v_313 * __v_290);
+    let __v_315: G = (__v_312 + __v_314);
+    let __v_316: G = (__v_310 + __v_315);
+    let __v_317: G = (__v_308 + __v_316);
+    let __v_318: G = (__v_306 + __v_317);
+    let __v_319: G = (__v_304 + __v_318);
+    let __v_320: G = (__v_302 + __v_319);
+    let __v_321: G = (__v_283 + __v_320);
+    if (__v_321 != __v_282) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_321.as_canonical_u64(), rhs: __v_282.as_canonical_u64(), msg: None });
+    }
+    let __v_322: G = G::from_u64(1);
+    let __v_323: G = G::from_u64(1);
+    let __v_324: G = (__v_323 - __v_300);
+    let __v_325: G = (__v_296 * __v_324);
+    let __v_326: G = (__v_322 - __v_325);
+    let __v_327: G = G::from_u64(1);
+    if (__v_326 != __v_327) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_326.as_canonical_u64(), rhs: __v_327.as_canonical_u64(), msg: None });
+    }
+    let __v_328: G = G::from_u64(0);
+    let __v_329: G = G::from_u64(0);
+    let __v_330: G = { let __values: [G; 10] = [__v_329, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_275]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_331: G = { let __values: [G; 10] = [__v_328, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_330]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_263, __v_331]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_332: 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_281.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_333: G = __loaded[0];
+    let __v_334: G = __loaded[1];
+    let __v_335: G = __loaded[2];
+    let __v_336: G = G::from_u64(1);
+    let __v_337: G = G::from_u64(1);
+    if (__v_333 != __v_336) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_333.as_canonical_u64(), rhs: __v_336.as_canonical_u64(), msg: None });
+    }
+    if (__v_334 != __v_337) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_334.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: None });
+    }
+    if (__v_335 != __v_337) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_335.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_236] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_332, __v_274, __v_277, __v_278, __v_280];
+    if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_237: usize = 13;
+const IN_237: usize = 13;
+const OUT_237: usize = 1;
+fn aiur_fn_237(
+  inp: [G; IN_237],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_237], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_14: G = __io_pair.0;
+    let __v_15: G = __io_pair.1;
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __v_23: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = __r_arr[0];
+    let __v_25: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; 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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __v_37: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+    let __v_45: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+    let __v_47: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __v_56: G = __r_arr[8];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
+    let __v_58: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; 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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_62: G = __r_arr[0];
+    let __v_63: G = __r_arr[1];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+    let __v_65: G = __r_arr[1];
+    let __v_66: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_67: G = __io_pair.0;
+    let __v_68: G = __io_pair.1;
+    let __v_69: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; 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_70: G = __r_arr[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_71: G = __r_arr[0];
+    let __v_72: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_72, __v_71]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    match __v_18.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
+        match __v_0.as_canonical_u64() {
+          _ => {
+            match __v_0.as_canonical_u64() {
+              _ => {
+                match __v_18.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_18]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_76: G = __r_arr[0];
+                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11, __v_18]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_77: G = __r_arr[0];
+                    match __v_20.as_canonical_u64() {
+                      _ => {
+                        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
+  0u64 => {
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_80];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_78: G = __mc_out___mc_0[0];
+                        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_30, __v_70]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
+                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_20, __v_79]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
+                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_78, __v_80]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
+                        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_81]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+                        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_82]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+                        let __v_84: G = G::from_u64(0);
+                        let __v_85: G = G::from_u64(109);
+                        let __v_86: G = G::from_u64(0);
+                        let __v_87: G = G::from_u64(117);
+                        let __v_88: G = G::from_u64(0);
+                        let __v_89: G = G::from_u64(108);
+                        let __v_90: G = G::from_u64(0);
+                        let __v_91: G = G::from_u64(116);
+                        let __v_92: G = G::from_u64(0);
+                        let __v_93: G = G::from_u64(105);
+                        let __v_94: G = G::from_u64(0);
+                        let __v_95: G = G::from_u64(45);
+                        let __v_96: G = G::from_u64(0);
+                        let __v_97: G = G::from_u64(115);
+                        let __v_98: G = G::from_u64(0);
+                        let __v_99: G = G::from_u64(116);
+                        let __v_100: G = G::from_u64(0);
+                        let __v_101: G = G::from_u64(97);
+                        let __v_102: G = G::from_u64(0);
+                        let __v_103: G = G::from_u64(114);
+                        let __v_104: G = G::from_u64(0);
+                        let __v_105: G = G::from_u64(107);
+                        let __v_106: G = G::from_u64(0);
+                        let __v_107: G = G::from_u64(47);
+                        let __v_108: G = G::from_u64(0);
+                        let __v_109: G = G::from_u64(118);
+                        let __v_110: G = G::from_u64(0);
+                        let __v_111: G = G::from_u64(48);
+                        let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_126: G = G::from_u64(1);
+                        let __v_127: G = G::from_u64(1);
+                        let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_125, __v_128]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
+                        let __v_130: G = __r_arr[1];
+                        let __v_131: G = __r_arr[2];
+                        let __v_132: G = __r_arr[3];
+                        let __v_133: G = __r_arr[4];
+                        let __v_134: G = __r_arr[5];
+                        let __v_135: G = __r_arr[6];
+                        let __v_136: G = __r_arr[7];
+                        let __v_137: G = __r_arr[8];
+                        let __v_138: G = __r_arr[9];
+                        let __v_139: G = __r_arr[10];
+                        let __v_140: G = __r_arr[11];
+                        let __v_141: G = __r_arr[12];
+                        let __v_142: G = __r_arr[13];
+                        let __v_143: G = __r_arr[14];
+                        let __v_144: G = __r_arr[15];
+                        let __v_145: G = __r_arr[16];
+                        let __v_146: G = __r_arr[17];
+                        let __v_147: G = G::from_u64(1);
+                        let __v_148: G = G::from_u64(1);
+                        let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_150: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+                        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_145, __v_151]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_152: G = __r_arr[0];
+                        let __v_153: G = G::from_u64(1);
+                        let __v_154: G = G::from_u64(1);
+                        let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_152, __v_155]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+                        let __v_157: G = __r_arr[1];
+                        let __v_158: G = __r_arr[2];
+                        let __v_159: G = __r_arr[3];
+                        let __v_160: G = __r_arr[4];
+                        let __v_161: G = __r_arr[5];
+                        let __v_162: G = __r_arr[6];
+                        let __v_163: G = __r_arr[7];
+                        let __v_164: G = __r_arr[8];
+                        let __v_165: G = __r_arr[9];
+                        let __v_166: G = __r_arr[10];
+                        let __v_167: G = __r_arr[11];
+                        let __v_168: G = __r_arr[12];
+                        let __v_169: G = __r_arr[13];
+                        let __v_170: G = __r_arr[14];
+                        let __v_171: G = __r_arr[15];
+                        let __v_172: G = __r_arr[16];
+                        let __v_173: G = __r_arr[17];
+                        let __v_174: G = G::from_u64(1);
+                        let __v_175: G = G::from_u64(1);
+                        let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_177: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_178: G = __r_arr[0];
+                        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_172, __v_178]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_179: G = __r_arr[0];
+                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_179, __v_22]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_180: G = __r_arr[0];
+                        let __v_181: G = G::from_u64(1);
+                        let __v_182: G = G::from_u64(1);
+                        let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_26, __v_183]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_184: G = __r_arr[0];
+                        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_180, __v_184]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_185: G = __r_arr[0];
+                        let __v_186: G = G::from_u64(1);
+                        let __v_187: G = G::from_u64(1);
+                        let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_185, __v_188]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_189: G = __r_arr[0];
+                        let __v_190: G = __r_arr[1];
+                        let __v_191: G = __r_arr[2];
+                        let __v_192: G = __r_arr[3];
+                        let __v_193: G = __r_arr[4];
+                        let __v_194: G = __r_arr[5];
+                        let __v_195: G = __r_arr[6];
+                        let __v_196: G = __r_arr[7];
+                        let __v_197: G = __r_arr[8];
+                        let __v_198: G = __r_arr[9];
+                        let __v_199: G = __r_arr[10];
+                        let __v_200: G = __r_arr[11];
+                        let __v_201: G = __r_arr[12];
+                        let __v_202: G = __r_arr[13];
+                        let __v_203: G = __r_arr[14];
+                        let __v_204: G = __r_arr[15];
+                        let __v_205: G = __r_arr[16];
+                        let __v_206: G = __r_arr[17];
+                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_205, __v_24]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_207: G = __r_arr[0];
+                        let __v_208: G = G::from_u64(1);
+                        let __v_209: G = G::from_u64(1);
+                        let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_207, __v_210]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_211: G = __r_arr[0];
+                        let __v_212: G = __r_arr[1];
+                        let __v_213: G = __r_arr[2];
+                        let __v_214: G = __r_arr[3];
+                        let __v_215: G = __r_arr[4];
+                        let __v_216: G = __r_arr[5];
+                        let __v_217: G = __r_arr[6];
+                        let __v_218: G = __r_arr[7];
+                        let __v_219: G = __r_arr[8];
+                        let __v_220: G = __r_arr[9];
+                        let __v_221: G = __r_arr[10];
+                        let __v_222: G = __r_arr[11];
+                        let __v_223: G = __r_arr[12];
+                        let __v_224: G = __r_arr[13];
+                        let __v_225: G = __r_arr[14];
+                        let __v_226: G = __r_arr[15];
+                        let __v_227: G = __r_arr[16];
+                        let __v_228: G = __r_arr[17];
+                        let __v_229: G = G::from_u64(256);
+                        let __v_230: G = (__v_229 * __v_130);
+                        let __v_231: G = G::from_u64(65536);
+                        let __v_232: G = (__v_231 * __v_131);
+                        let __v_233: G = G::from_u64(16777216);
+                        let __v_234: G = (__v_233 * __v_132);
+                        let __v_235: G = G::from_u64(4294967296);
+                        let __v_236: G = (__v_235 * __v_133);
+                        let __v_237: G = G::from_u64(1099511627776);
+                        let __v_238: G = (__v_237 * __v_134);
+                        let __v_239: G = G::from_u64(281474976710656);
+                        let __v_240: G = (__v_239 * __v_135);
+                        let __v_241: G = G::from_u64(72057594037927936);
+                        let __v_242: G = (__v_241 * __v_136);
+                        let __v_243: G = (__v_240 + __v_242);
+                        let __v_244: G = (__v_238 + __v_243);
+                        let __v_245: G = (__v_236 + __v_244);
+                        let __v_246: G = (__v_234 + __v_245);
+                        let __v_247: G = (__v_232 + __v_246);
+                        let __v_248: G = (__v_230 + __v_247);
+                        let __v_249: G = (__v_129 + __v_248);
+                        let __v_250: G = G::from_u64(256);
+                        let __v_251: G = (__v_250 * __v_138);
+                        let __v_252: G = G::from_u64(65536);
+                        let __v_253: G = (__v_252 * __v_139);
+                        let __v_254: G = G::from_u64(16777216);
+                        let __v_255: G = (__v_254 * __v_140);
+                        let __v_256: G = G::from_u64(4294967296);
+                        let __v_257: G = (__v_256 * __v_141);
+                        let __v_258: G = G::from_u64(1099511627776);
+                        let __v_259: G = (__v_258 * __v_142);
+                        let __v_260: G = G::from_u64(281474976710656);
+                        let __v_261: G = (__v_260 * __v_143);
+                        let __v_262: G = G::from_u64(72057594037927936);
+                        let __v_263: G = (__v_262 * __v_144);
+                        let __v_264: G = (__v_261 + __v_263);
+                        let __v_265: G = (__v_259 + __v_264);
+                        let __v_266: G = (__v_257 + __v_265);
+                        let __v_267: G = (__v_255 + __v_266);
+                        let __v_268: G = (__v_253 + __v_267);
+                        let __v_269: G = (__v_251 + __v_268);
+                        let __v_270: G = (__v_137 + __v_269);
+                        let __v_271: G = G::from_u64(256);
+                        let __v_272: G = (__v_271 * __v_157);
+                        let __v_273: G = G::from_u64(65536);
+                        let __v_274: G = (__v_273 * __v_158);
+                        let __v_275: G = G::from_u64(16777216);
+                        let __v_276: G = (__v_275 * __v_159);
+                        let __v_277: G = G::from_u64(4294967296);
+                        let __v_278: G = (__v_277 * __v_160);
+                        let __v_279: G = G::from_u64(1099511627776);
+                        let __v_280: G = (__v_279 * __v_161);
+                        let __v_281: G = G::from_u64(281474976710656);
+                        let __v_282: G = (__v_281 * __v_162);
+                        let __v_283: G = G::from_u64(72057594037927936);
+                        let __v_284: G = (__v_283 * __v_163);
+                        let __v_285: G = (__v_282 + __v_284);
+                        let __v_286: G = (__v_280 + __v_285);
+                        let __v_287: G = (__v_278 + __v_286);
+                        let __v_288: G = (__v_276 + __v_287);
+                        let __v_289: G = (__v_274 + __v_288);
+                        let __v_290: G = (__v_272 + __v_289);
+                        let __v_291: G = (__v_156 + __v_290);
+                        let __v_292: G = G::from_u64(256);
+                        let __v_293: G = (__v_292 * __v_165);
+                        let __v_294: G = G::from_u64(65536);
+                        let __v_295: G = (__v_294 * __v_166);
+                        let __v_296: G = G::from_u64(16777216);
+                        let __v_297: G = (__v_296 * __v_167);
+                        let __v_298: G = G::from_u64(4294967296);
+                        let __v_299: G = (__v_298 * __v_168);
+                        let __v_300: G = G::from_u64(1099511627776);
+                        let __v_301: G = (__v_300 * __v_169);
+                        let __v_302: G = G::from_u64(281474976710656);
+                        let __v_303: G = (__v_302 * __v_170);
+                        let __v_304: G = G::from_u64(72057594037927936);
+                        let __v_305: G = (__v_304 * __v_171);
+                        let __v_306: G = (__v_303 + __v_305);
+                        let __v_307: G = (__v_301 + __v_306);
+                        let __v_308: G = (__v_299 + __v_307);
+                        let __v_309: G = (__v_297 + __v_308);
+                        let __v_310: G = (__v_295 + __v_309);
+                        let __v_311: G = (__v_293 + __v_310);
+                        let __v_312: G = (__v_164 + __v_311);
+                        let __v_313: G = G::from_u64(256);
+                        let __v_314: G = (__v_313 * __v_190);
+                        let __v_315: G = G::from_u64(65536);
+                        let __v_316: G = (__v_315 * __v_191);
+                        let __v_317: G = G::from_u64(16777216);
+                        let __v_318: G = (__v_317 * __v_192);
+                        let __v_319: G = G::from_u64(4294967296);
+                        let __v_320: G = (__v_319 * __v_193);
+                        let __v_321: G = G::from_u64(1099511627776);
+                        let __v_322: G = (__v_321 * __v_194);
+                        let __v_323: G = G::from_u64(281474976710656);
+                        let __v_324: G = (__v_323 * __v_195);
+                        let __v_325: G = G::from_u64(72057594037927936);
+                        let __v_326: G = (__v_325 * __v_196);
+                        let __v_327: G = (__v_324 + __v_326);
+                        let __v_328: G = (__v_322 + __v_327);
+                        let __v_329: G = (__v_320 + __v_328);
+                        let __v_330: G = (__v_318 + __v_329);
+                        let __v_331: G = (__v_316 + __v_330);
+                        let __v_332: G = (__v_314 + __v_331);
+                        let __v_333: G = (__v_189 + __v_332);
+                        let __v_334: G = G::from_u64(256);
+                        let __v_335: G = (__v_334 * __v_198);
+                        let __v_336: G = G::from_u64(65536);
+                        let __v_337: G = (__v_336 * __v_199);
+                        let __v_338: G = G::from_u64(16777216);
+                        let __v_339: G = (__v_338 * __v_200);
+                        let __v_340: G = G::from_u64(4294967296);
+                        let __v_341: G = (__v_340 * __v_201);
+                        let __v_342: G = G::from_u64(1099511627776);
+                        let __v_343: G = (__v_342 * __v_202);
+                        let __v_344: G = G::from_u64(281474976710656);
+                        let __v_345: G = (__v_344 * __v_203);
+                        let __v_346: G = G::from_u64(72057594037927936);
+                        let __v_347: G = (__v_346 * __v_204);
+                        let __v_348: G = (__v_345 + __v_347);
+                        let __v_349: G = (__v_343 + __v_348);
+                        let __v_350: G = (__v_341 + __v_349);
+                        let __v_351: G = (__v_339 + __v_350);
+                        let __v_352: G = (__v_337 + __v_351);
+                        let __v_353: G = (__v_335 + __v_352);
+                        let __v_354: G = (__v_197 + __v_353);
+                        let __v_355: G = G::from_u64(256);
+                        let __v_356: G = (__v_355 * __v_212);
+                        let __v_357: G = G::from_u64(65536);
+                        let __v_358: G = (__v_357 * __v_213);
+                        let __v_359: G = G::from_u64(16777216);
+                        let __v_360: G = (__v_359 * __v_214);
+                        let __v_361: G = G::from_u64(4294967296);
+                        let __v_362: G = (__v_361 * __v_215);
+                        let __v_363: G = G::from_u64(1099511627776);
+                        let __v_364: G = (__v_363 * __v_216);
+                        let __v_365: G = G::from_u64(281474976710656);
+                        let __v_366: G = (__v_365 * __v_217);
+                        let __v_367: G = G::from_u64(72057594037927936);
+                        let __v_368: G = (__v_367 * __v_218);
+                        let __v_369: G = (__v_366 + __v_368);
+                        let __v_370: G = (__v_364 + __v_369);
+                        let __v_371: G = (__v_362 + __v_370);
+                        let __v_372: G = (__v_360 + __v_371);
+                        let __v_373: G = (__v_358 + __v_372);
+                        let __v_374: G = (__v_356 + __v_373);
+                        let __v_375: G = (__v_211 + __v_374);
+                        let __v_376: G = G::from_u64(256);
+                        let __v_377: G = (__v_376 * __v_220);
+                        let __v_378: G = G::from_u64(65536);
+                        let __v_379: G = (__v_378 * __v_221);
+                        let __v_380: G = G::from_u64(16777216);
+                        let __v_381: G = (__v_380 * __v_222);
+                        let __v_382: G = G::from_u64(4294967296);
+                        let __v_383: G = (__v_382 * __v_223);
+                        let __v_384: G = G::from_u64(1099511627776);
+                        let __v_385: G = (__v_384 * __v_224);
+                        let __v_386: G = G::from_u64(281474976710656);
+                        let __v_387: G = (__v_386 * __v_225);
+                        let __v_388: G = G::from_u64(72057594037927936);
+                        let __v_389: G = (__v_388 * __v_226);
+                        let __v_390: G = (__v_387 + __v_389);
+                        let __v_391: G = (__v_385 + __v_390);
+                        let __v_392: G = (__v_383 + __v_391);
+                        let __v_393: G = (__v_381 + __v_392);
+                        let __v_394: G = (__v_379 + __v_393);
+                        let __v_395: G = (__v_377 + __v_394);
+                        let __v_396: G = (__v_219 + __v_395);
+                        let __v_397: G = G::from_u64(0);
+                        let __v_398: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_399: G = __r_arr[0];
+                        let __v_400: G = __r_arr[1];
+                        let __v_401: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_402: G = __r_arr[0];
+                        let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_403: G = __r_arr[0];
+                        match __v_34.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_34]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_404: G = __r_arr[0];
+                            let __v_405: G = G::from_u64(1);
+                            let __v_406: G = G::from_u64(1);
+                            let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_407];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_60, __v_407]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_408: G = __r_arr[0];
+    break '__mc_1 [__v_408];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
+  },
+}
+ };
+                            let __v_408: G = __mc_out___mc_1[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_57, __v_408]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_409: G = __r_arr[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_409]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_410: G = __r_arr[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_62, __v_410]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_411: G = __r_arr[0];
+                            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_227, __v_411]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_412: G = __r_arr[0];
+                            let __v_413: G = G::from_u64(1);
+                            let __v_414: G = G::from_u64(1);
+                            let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_412, __v_415]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_416: G = __r_arr[0];
+                            let __v_417: G = __r_arr[1];
+                            let __v_418: G = __r_arr[2];
+                            let __v_419: G = __r_arr[3];
+                            let __v_420: G = __r_arr[4];
+                            let __v_421: G = __r_arr[5];
+                            let __v_422: G = __r_arr[6];
+                            let __v_423: G = __r_arr[7];
+                            let __v_424: G = __r_arr[8];
+                            let __v_425: G = __r_arr[9];
+                            let __v_426: G = __r_arr[10];
+                            let __v_427: G = __r_arr[11];
+                            let __v_428: G = __r_arr[12];
+                            let __v_429: G = __r_arr[13];
+                            let __v_430: G = __r_arr[14];
+                            let __v_431: G = __r_arr[15];
+                            let __v_432: G = __r_arr[16];
+                            let __v_433: G = __r_arr[17];
+                            let __v_434: G = G::from_u64(256);
+                            let __v_435: G = (__v_434 * __v_417);
+                            let __v_436: G = G::from_u64(65536);
+                            let __v_437: G = (__v_436 * __v_418);
+                            let __v_438: G = G::from_u64(16777216);
+                            let __v_439: G = (__v_438 * __v_419);
+                            let __v_440: G = G::from_u64(4294967296);
+                            let __v_441: G = (__v_440 * __v_420);
+                            let __v_442: G = G::from_u64(1099511627776);
+                            let __v_443: G = (__v_442 * __v_421);
+                            let __v_444: G = G::from_u64(281474976710656);
+                            let __v_445: G = (__v_444 * __v_422);
+                            let __v_446: G = G::from_u64(72057594037927936);
+                            let __v_447: G = (__v_446 * __v_423);
+                            let __v_448: G = (__v_445 + __v_447);
+                            let __v_449: G = (__v_443 + __v_448);
+                            let __v_450: G = (__v_441 + __v_449);
+                            let __v_451: G = (__v_439 + __v_450);
+                            let __v_452: G = (__v_437 + __v_451);
+                            let __v_453: G = (__v_435 + __v_452);
+                            let __v_454: G = (__v_416 + __v_453);
+                            let __v_455: G = G::from_u64(256);
+                            let __v_456: G = (__v_455 * __v_425);
+                            let __v_457: G = G::from_u64(65536);
+                            let __v_458: G = (__v_457 * __v_426);
+                            let __v_459: G = G::from_u64(16777216);
+                            let __v_460: G = (__v_459 * __v_427);
+                            let __v_461: G = G::from_u64(4294967296);
+                            let __v_462: G = (__v_461 * __v_428);
+                            let __v_463: G = G::from_u64(1099511627776);
+                            let __v_464: G = (__v_463 * __v_429);
+                            let __v_465: G = G::from_u64(281474976710656);
+                            let __v_466: G = (__v_465 * __v_430);
+                            let __v_467: G = G::from_u64(72057594037927936);
+                            let __v_468: G = (__v_467 * __v_431);
+                            let __v_469: G = (__v_466 + __v_468);
+                            let __v_470: G = (__v_464 + __v_469);
+                            let __v_471: G = (__v_462 + __v_470);
+                            let __v_472: G = (__v_460 + __v_471);
+                            let __v_473: G = (__v_458 + __v_472);
+                            let __v_474: G = (__v_456 + __v_473);
+                            let __v_475: G = (__v_424 + __v_474);
+                            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_432, __v_34, __v_36, __v_5]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_476: G = __r_arr[0];
+                            let __v_477: G = __r_arr[1];
+                            let __v_478: G = G::from_u64(1);
+                            let __v_479: G = G::from_u64(1);
+                            let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_46, __v_480]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_481: G = __r_arr[0];
+                            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_477, __v_481]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_482: G = __r_arr[0];
+                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_482, __v_34]; 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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_483: G = __r_arr[0];
+                            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_484: G = __r_arr[0];
+                            let __v_485: G = __r_arr[1];
+                            let __v_486: G = (__v_404 + __v_0);
+                            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_4, __v_486]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_487: G = __r_arr[0];
+                            let __v_488: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_40, __v_44, __v_488, __v_4]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_489: G = __r_arr[0];
+                            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_490: G = __r_arr[0];
+                            let __v_491: G = (__v_14 + __v_15);
+                            if (__v_65 != __v_491) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_491.as_canonical_u64(), msg: None });
+                            }
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_492: G = __loaded[0];
+                            let __v_493: G = __loaded[1];
+                            let __v_494: G = __loaded[2];
+                            let __v_495: G = G::from_u64(1);
+                            let __v_496: G = G::from_u64(1);
+                            if (__v_492 != __v_495) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_492.as_canonical_u64(), rhs: __v_495.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_493 != __v_496) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_494 != __v_496) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_494.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: None });
+                            }
+                            let __v_497: G = G::from_bool((__v_75 == G::ZERO));
+                            let __v_498: G = G::from_u64(0);
+                            if (__v_497 != __v_498) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_497.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_62]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_499: G = __r_arr[0];
+                            if (__v_499 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_499.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_64]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_500: G = __r_arr[0];
+                            if (__v_500 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_500.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_57]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_501: G = __r_arr[0];
+                            if (__v_501 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_501.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_26]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_502: G = __r_arr[0];
+                            let __v_503: G = G::from_u64(1);
+                            if (__v_502 != __v_503) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_503.as_canonical_u64(), msg: None });
+                            }
+                            let __v_504: G = G::from_u64(1);
+                            let __v_505: G = G::from_u64(1);
+                            if (__v_504 != __v_505) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_504.as_canonical_u64(), rhs: __v_505.as_canonical_u64(), msg: None });
+                            }
+                            let __v_506: G = G::from_u64(0);
+                            if (__v_1 != __v_506) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_506.as_canonical_u64(), msg: None });
+                            }
+                            let __v_507: G = G::from_u64(0);
+                            if (__v_2 != __v_507) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_507.as_canonical_u64(), msg: None });
+                            }
+                            let __v_508: G = G::from_u64(1);
+                            if (__v_3 != __v_508) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_508.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_18]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_509: G = __r_arr[0];
+                            let __v_510: G = G::from_u64(1);
+                            if (__v_509 != __v_510) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_510.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_511: G = __r_arr[0];
+                            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_512: G = __r_arr[0];
+                            let __v_513: G = (__v_511 - __v_512);
+                            let __v_514: G = G::from_bool((__v_513 == G::ZERO));
+                            let __v_515: G = G::from_u64(1);
+                            if (__v_514 != __v_515) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_516: G = __r_arr[0];
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_517: G = __r_arr[0];
+                            let __v_518: G = (__v_516 - __v_517);
+                            let __v_519: G = G::from_bool((__v_518 == G::ZERO));
+                            let __v_520: G = G::from_u64(1);
+                            if (__v_519 != __v_520) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_519.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_36]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_521: G = __r_arr[0];
+                            let __v_522: G = (__v_521 - __v_404);
+                            let __v_523: G = G::from_bool((__v_522 == G::ZERO));
+                            let __v_524: G = G::from_u64(1);
+                            if (__v_523 != __v_524) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_524.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_40]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_525: G = __r_arr[0];
+                            let __v_526: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_59, __v_60]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_527: G = __r_arr[0];
+                            let __v_528: G = (__v_526 + __v_527);
+                            if (__v_525 != __v_528) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_528.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_44]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_529: G = __r_arr[0];
+                            let __v_530: G = (__v_529 - __v_404);
+                            let __v_531: G = G::from_bool((__v_530 == G::ZERO));
+                            let __v_532: G = G::from_u64(1);
+                            if (__v_531 != __v_532) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_531.as_canonical_u64(), rhs: __v_532.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_46]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_533: G = __r_arr[0];
+                            let __v_534: G = G::from_u64(1);
+                            if (__v_533 != __v_534) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_533.as_canonical_u64(), rhs: __v_534.as_canonical_u64(), msg: None });
+                            }
+                            let __v_535: G = G::from_u64(33);
+                            let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                            let __v_537: G = G::from_u64(1);
+                            if (__v_536 != __v_537) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_536.as_canonical_u64(), rhs: __v_537.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_538: G = __r_arr[0];
+                            let __v_539: G = G::from_u64(1);
+                            if (__v_538 != __v_539) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_538.as_canonical_u64(), rhs: __v_539.as_canonical_u64(), msg: None });
+                            }
+                            let __v_540: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_541: G = __r_arr[0];
+                            let __v_542: G = G::from_u64(1);
+                            if (__v_541 != __v_542) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_542.as_canonical_u64(), msg: None });
+                            }
+                            let __ret: [G; OUT_237] = [__v_73];
+                            if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_238: usize = 28;
+const IN_238: usize = 28;
+const OUT_238: usize = 8;
+fn aiur_fn_238(
+  inp: [G; IN_238],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_238], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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 { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __v_30: G = __r_arr[2];
+    let __v_31: G = __r_arr[3];
+    let __v_32: G = __r_arr[4];
+    let __v_33: G = __r_arr[5];
+    let __v_34: G = __r_arr[6];
+    let __v_35: G = __r_arr[7];
+    let __v_36: G = __r_arr[8];
+    let __v_37: G = __r_arr[9];
+    let __v_38: G = __r_arr[10];
+    let __v_39: G = __r_arr[11];
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; 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 { let __r = record.function_queries[237].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_40]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = G::from_u64(0);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_41, __v_42]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
+    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("aggr: child has the wrong claim channel".to_string()) });
+    }
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_41]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+        let __v_46: G = G::from_u64(10);
+        if (__v_45 != __v_46) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr: IxVM child must expose a 10-word verify_claim claim".to_string()) });
+        }
+        let __v_47: G = G::from_u64(1);
+        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_41, __v_47]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+        if (__v_48 != __v_18) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: IxVM child has the wrong entrypoint".to_string()) });
+        }
+        let __v_49: G = G::from_u64(2);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_49]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_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 __ret: [G; OUT_238] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57];
+        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_45: G = G::from_u64(2);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_45]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __v_47: G = __r_arr[1];
+        let __v_48: G = __r_arr[2];
+        let __v_49: G = __r_arr[3];
+        let __v_50: G = __r_arr[4];
+        let __v_51: G = __r_arr[5];
+        let __v_52: G = __r_arr[6];
+        let __v_53: G = __r_arr[7];
+        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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_249] = { let __args: [G; IN_249] = [__v_41]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
+        let __v_55: G = G::from_u64(18);
+        if (__v_54 != __v_55) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("aggr: recursive child must expose an 18-word ix_aggr claim".to_string()) });
+        }
+        let __v_56: G = G::from_u64(1);
+        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_41, __v_56]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
+        if (__v_57 != __v_19) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: recursive child has the wrong entrypoint".to_string()) });
+        }
+        let __v_58: G = G::from_u64(10);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_58]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+        let __v_60: G = __r_arr[1];
+        let __v_61: G = __r_arr[2];
+        let __v_62: G = __r_arr[3];
+        let __v_63: G = __r_arr[4];
+        let __v_64: G = __r_arr[5];
+        let __v_65: G = __r_arr[6];
+        let __v_66: G = __r_arr[7];
+        let __ret: [G; OUT_238] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66];
+        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_239: usize = 35;
+const IN_239: usize = 35;
+const OUT_239: usize = 0;
+fn aiur_fn_239(
+  inp: [G; IN_239],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_239], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = G::from_u64(0);
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; 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 { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+    let __v_37: G = __r_arr[1];
+    let __v_38: G = __r_arr[2];
+    let __v_39: G = __r_arr[3];
+    let __v_40: G = __r_arr[4];
+    let __v_41: G = __r_arr[5];
+    let __v_42: G = __r_arr[6];
+    let __v_43: G = __r_arr[7];
+    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_239] = [];
+    if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_240: usize = 36;
+const IN_240: usize = 36;
+const OUT_240: usize = 0;
+fn aiur_fn_240(
+  inp: [G; IN_240],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_240], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = G::from_u64(0);
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    let __v_39: G = __r_arr[2];
+    let __v_40: G = __r_arr[3];
+    let __v_41: G = __r_arr[4];
+    let __v_42: G = __r_arr[5];
+    let __v_43: G = __r_arr[6];
+    let __v_44: G = __r_arr[7];
+    let __v_45: G = G::from_u64(1);
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+    let __v_47: G = __r_arr[1];
+    let __v_48: G = __r_arr[2];
+    let __v_49: G = __r_arr[3];
+    let __v_50: G = __r_arr[4];
+    let __v_51: G = __r_arr[5];
+    let __v_52: G = __r_arr[6];
+    let __v_53: G = __r_arr[7];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_54]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+    let __v_56: G = __r_arr[1];
+    let __v_57: G = __r_arr[2];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_58: G = __r_arr[0];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_58]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __v_62: G = G::from_u64(2);
+    let __v_63: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_63]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_64: G = __io_pair.0;
+    let __v_65: G = __io_pair.1;
+    let __v_66: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; 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_67: G = __r_arr[0];
+    let __v_68: G = G::from_u64(103);
+    let __v_69: G = G::from_u64(230);
+    let __v_70: G = G::from_u64(9);
+    let __v_71: G = G::from_u64(106);
+    let __v_72: G = G::from_u64(133);
+    let __v_73: G = G::from_u64(174);
+    let __v_74: G = G::from_u64(103);
+    let __v_75: G = G::from_u64(187);
+    let __v_76: G = G::from_u64(114);
+    let __v_77: G = G::from_u64(243);
+    let __v_78: G = G::from_u64(110);
+    let __v_79: G = G::from_u64(60);
+    let __v_80: G = G::from_u64(58);
+    let __v_81: G = G::from_u64(245);
+    let __v_82: G = G::from_u64(79);
+    let __v_83: G = G::from_u64(165);
+    let __v_84: G = G::from_u64(127);
+    let __v_85: G = G::from_u64(82);
+    let __v_86: G = G::from_u64(14);
+    let __v_87: G = G::from_u64(81);
+    let __v_88: G = G::from_u64(140);
+    let __v_89: G = G::from_u64(104);
+    let __v_90: G = G::from_u64(5);
+    let __v_91: G = G::from_u64(155);
+    let __v_92: G = G::from_u64(171);
+    let __v_93: G = G::from_u64(217);
+    let __v_94: G = G::from_u64(131);
+    let __v_95: G = G::from_u64(31);
+    let __v_96: G = G::from_u64(25);
+    let __v_97: G = G::from_u64(205);
+    let __v_98: G = G::from_u64(224);
+    let __v_99: G = G::from_u64(91);
+    let __v_100: G = G::from_u64(1);
+    let __v_101: G = G::from_u64(1);
+    let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_103: G = G::from_u64(0);
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(0);
+    let __v_106: G = G::from_u64(0);
+    let __v_107: G = G::from_u64(0);
+    let __v_108: G = G::from_u64(0);
+    let __v_109: G = G::from_u64(0);
+    let __v_110: G = G::from_u64(0);
+    let __v_111: G = G::from_u64(0);
+    let __v_112: G = G::from_u64(0);
+    let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_114: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_115: G = G::from_u64(1);
+    let __v_116: G = G::from_u64(1);
+    let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __v_121: G = __r_arr[2];
+    let __v_122: G = __r_arr[3];
+    let __v_123: G = __r_arr[4];
+    let __v_124: G = __r_arr[5];
+    let __v_125: G = __r_arr[6];
+    let __v_126: G = __r_arr[7];
+    let __v_127: G = __r_arr[8];
+    let __v_128: G = __r_arr[9];
+    let __v_129: G = __r_arr[10];
+    let __v_130: G = __r_arr[11];
+    let __v_131: G = __r_arr[12];
+    let __v_132: G = __r_arr[13];
+    let __v_133: G = __r_arr[14];
+    let __v_134: G = __r_arr[15];
+    let __v_135: G = __r_arr[16];
+    let __v_136: G = __r_arr[17];
+    let __v_137: G = __r_arr[18];
+    let __v_138: G = __r_arr[19];
+    let __v_139: G = __r_arr[20];
+    let __v_140: G = __r_arr[21];
+    let __v_141: G = __r_arr[22];
+    let __v_142: G = __r_arr[23];
+    let __v_143: G = __r_arr[24];
+    let __v_144: G = __r_arr[25];
+    let __v_145: G = __r_arr[26];
+    let __v_146: G = __r_arr[27];
+    let __v_147: G = __r_arr[28];
+    let __v_148: G = __r_arr[29];
+    let __v_149: G = __r_arr[30];
+    let __v_150: G = __r_arr[31];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_67]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __v_153: G = __r_arr[2];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_55]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_154: G = __r_arr[0];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_59]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_56, __v_57]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_60, __v_61]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_151]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_158: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_152, __v_153]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_159: G = __r_arr[0];
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_154, __v_155, __v_158]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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_225] = { let __args: [G; IN_225] = [__v_156, __v_157, __v_158, __v_159]; 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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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_160: G = G::from_u64(256);
+    let __v_161: G = (__v_160 * __v_120);
+    let __v_162: G = G::from_u64(65536);
+    let __v_163: G = (__v_162 * __v_121);
+    let __v_164: G = G::from_u64(16777216);
+    let __v_165: G = (__v_164 * __v_122);
+    let __v_166: G = (__v_163 + __v_165);
+    let __v_167: G = (__v_161 + __v_166);
+    let __v_168: G = (__v_119 + __v_167);
+    let __v_169: G = G::from_u64(256);
+    let __v_170: G = (__v_169 * __v_124);
+    let __v_171: G = G::from_u64(65536);
+    let __v_172: G = (__v_171 * __v_125);
+    let __v_173: G = G::from_u64(16777216);
+    let __v_174: G = (__v_173 * __v_126);
+    let __v_175: G = (__v_172 + __v_174);
+    let __v_176: G = (__v_170 + __v_175);
+    let __v_177: G = (__v_123 + __v_176);
+    let __v_178: G = G::from_u64(256);
+    let __v_179: G = (__v_178 * __v_128);
+    let __v_180: G = G::from_u64(65536);
+    let __v_181: G = (__v_180 * __v_129);
+    let __v_182: G = G::from_u64(16777216);
+    let __v_183: G = (__v_182 * __v_130);
+    let __v_184: G = (__v_181 + __v_183);
+    let __v_185: G = (__v_179 + __v_184);
+    let __v_186: G = (__v_127 + __v_185);
+    let __v_187: G = G::from_u64(256);
+    let __v_188: G = (__v_187 * __v_132);
+    let __v_189: G = G::from_u64(65536);
+    let __v_190: G = (__v_189 * __v_133);
+    let __v_191: G = G::from_u64(16777216);
+    let __v_192: G = (__v_191 * __v_134);
+    let __v_193: G = (__v_190 + __v_192);
+    let __v_194: G = (__v_188 + __v_193);
+    let __v_195: G = (__v_131 + __v_194);
+    let __v_196: G = G::from_u64(256);
+    let __v_197: G = (__v_196 * __v_136);
+    let __v_198: G = G::from_u64(65536);
+    let __v_199: G = (__v_198 * __v_137);
+    let __v_200: G = G::from_u64(16777216);
+    let __v_201: G = (__v_200 * __v_138);
+    let __v_202: G = (__v_199 + __v_201);
+    let __v_203: G = (__v_197 + __v_202);
+    let __v_204: G = (__v_135 + __v_203);
+    let __v_205: G = G::from_u64(256);
+    let __v_206: G = (__v_205 * __v_140);
+    let __v_207: G = G::from_u64(65536);
+    let __v_208: G = (__v_207 * __v_141);
+    let __v_209: G = G::from_u64(16777216);
+    let __v_210: G = (__v_209 * __v_142);
+    let __v_211: G = (__v_208 + __v_210);
+    let __v_212: G = (__v_206 + __v_211);
+    let __v_213: G = (__v_139 + __v_212);
+    let __v_214: G = G::from_u64(256);
+    let __v_215: G = (__v_214 * __v_144);
+    let __v_216: G = G::from_u64(65536);
+    let __v_217: G = (__v_216 * __v_145);
+    let __v_218: G = G::from_u64(16777216);
+    let __v_219: G = (__v_218 * __v_146);
+    let __v_220: G = (__v_217 + __v_219);
+    let __v_221: G = (__v_215 + __v_220);
+    let __v_222: G = (__v_143 + __v_221);
+    let __v_223: G = G::from_u64(256);
+    let __v_224: G = (__v_223 * __v_148);
+    let __v_225: G = G::from_u64(65536);
+    let __v_226: G = (__v_225 * __v_149);
+    let __v_227: G = G::from_u64(16777216);
+    let __v_228: G = (__v_227 * __v_150);
+    let __v_229: G = (__v_226 + __v_228);
+    let __v_230: G = (__v_224 + __v_229);
+    let __v_231: G = (__v_147 + __v_230);
+    if (__v_168 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_168.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_177 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_177.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_186 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_195 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_204 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_213 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_213.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_222 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_222.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    if (__v_231 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) });
+    }
+    let __ret: [G; OUT_240] = [];
+    if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_241: usize = 36;
+const IN_241: usize = 36;
+const OUT_241: usize = 0;
+fn aiur_fn_241(
+  inp: [G; IN_241],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_241], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = G::from_u64(0);
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+    let __v_38: G = __r_arr[1];
+    let __v_39: G = __r_arr[2];
+    let __v_40: G = __r_arr[3];
+    let __v_41: G = __r_arr[4];
+    let __v_42: G = __r_arr[5];
+    let __v_43: G = __r_arr[6];
+    let __v_44: G = __r_arr[7];
+    let __v_45: G = G::from_u64(1);
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+    let __v_47: G = __r_arr[1];
+    let __v_48: G = __r_arr[2];
+    let __v_49: G = __r_arr[3];
+    let __v_50: G = __r_arr[4];
+    let __v_51: G = __r_arr[5];
+    let __v_52: G = __r_arr[6];
+    let __v_53: G = __r_arr[7];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_54]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+    let __v_56: G = __r_arr[1];
+    let __v_57: G = __r_arr[2];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_58: G = __r_arr[0];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_58]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __v_62: G = G::from_u64(2);
+    let __v_63: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_63]; let __info = io_buffer.get_info(__v_62, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_64: G = __io_pair.0;
+    let __v_65: G = __io_pair.1;
+    let __v_66: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; 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_67: G = __r_arr[0];
+    let __v_68: G = G::from_u64(103);
+    let __v_69: G = G::from_u64(230);
+    let __v_70: G = G::from_u64(9);
+    let __v_71: G = G::from_u64(106);
+    let __v_72: G = G::from_u64(133);
+    let __v_73: G = G::from_u64(174);
+    let __v_74: G = G::from_u64(103);
+    let __v_75: G = G::from_u64(187);
+    let __v_76: G = G::from_u64(114);
+    let __v_77: G = G::from_u64(243);
+    let __v_78: G = G::from_u64(110);
+    let __v_79: G = G::from_u64(60);
+    let __v_80: G = G::from_u64(58);
+    let __v_81: G = G::from_u64(245);
+    let __v_82: G = G::from_u64(79);
+    let __v_83: G = G::from_u64(165);
+    let __v_84: G = G::from_u64(127);
+    let __v_85: G = G::from_u64(82);
+    let __v_86: G = G::from_u64(14);
+    let __v_87: G = G::from_u64(81);
+    let __v_88: G = G::from_u64(140);
+    let __v_89: G = G::from_u64(104);
+    let __v_90: G = G::from_u64(5);
+    let __v_91: G = G::from_u64(155);
+    let __v_92: G = G::from_u64(171);
+    let __v_93: G = G::from_u64(217);
+    let __v_94: G = G::from_u64(131);
+    let __v_95: G = G::from_u64(31);
+    let __v_96: G = G::from_u64(25);
+    let __v_97: G = G::from_u64(205);
+    let __v_98: G = G::from_u64(224);
+    let __v_99: G = G::from_u64(91);
+    let __v_100: G = G::from_u64(1);
+    let __v_101: G = G::from_u64(1);
+    let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_103: G = G::from_u64(0);
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(0);
+    let __v_106: G = G::from_u64(0);
+    let __v_107: G = G::from_u64(0);
+    let __v_108: G = G::from_u64(0);
+    let __v_109: G = G::from_u64(0);
+    let __v_110: G = G::from_u64(0);
+    let __v_111: G = G::from_u64(0);
+    let __v_112: G = G::from_u64(0);
+    let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_114: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_115: G = G::from_u64(1);
+    let __v_116: G = G::from_u64(1);
+    let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __v_121: G = __r_arr[2];
+    let __v_122: G = __r_arr[3];
+    let __v_123: G = __r_arr[4];
+    let __v_124: G = __r_arr[5];
+    let __v_125: G = __r_arr[6];
+    let __v_126: G = __r_arr[7];
+    let __v_127: G = __r_arr[8];
+    let __v_128: G = __r_arr[9];
+    let __v_129: G = __r_arr[10];
+    let __v_130: G = __r_arr[11];
+    let __v_131: G = __r_arr[12];
+    let __v_132: G = __r_arr[13];
+    let __v_133: G = __r_arr[14];
+    let __v_134: G = __r_arr[15];
+    let __v_135: G = __r_arr[16];
+    let __v_136: G = __r_arr[17];
+    let __v_137: G = __r_arr[18];
+    let __v_138: G = __r_arr[19];
+    let __v_139: G = __r_arr[20];
+    let __v_140: G = __r_arr[21];
+    let __v_141: G = __r_arr[22];
+    let __v_142: G = __r_arr[23];
+    let __v_143: G = __r_arr[24];
+    let __v_144: G = __r_arr[25];
+    let __v_145: G = __r_arr[26];
+    let __v_146: G = __r_arr[27];
+    let __v_147: G = __r_arr[28];
+    let __v_148: G = __r_arr[29];
+    let __v_149: G = __r_arr[30];
+    let __v_150: G = __r_arr[31];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_67]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __v_153: G = __r_arr[2];
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_55, __v_59]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_154: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_56, __v_57]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_60, __v_61]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_152, __v_153]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_155, __v_156, __v_151, __v_157]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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_158: G = G::from_u64(256);
+    let __v_159: G = (__v_158 * __v_120);
+    let __v_160: G = G::from_u64(65536);
+    let __v_161: G = (__v_160 * __v_121);
+    let __v_162: G = G::from_u64(16777216);
+    let __v_163: G = (__v_162 * __v_122);
+    let __v_164: G = (__v_161 + __v_163);
+    let __v_165: G = (__v_159 + __v_164);
+    let __v_166: G = (__v_119 + __v_165);
+    let __v_167: G = G::from_u64(256);
+    let __v_168: G = (__v_167 * __v_124);
+    let __v_169: G = G::from_u64(65536);
+    let __v_170: G = (__v_169 * __v_125);
+    let __v_171: G = G::from_u64(16777216);
+    let __v_172: G = (__v_171 * __v_126);
+    let __v_173: G = (__v_170 + __v_172);
+    let __v_174: G = (__v_168 + __v_173);
+    let __v_175: G = (__v_123 + __v_174);
+    let __v_176: G = G::from_u64(256);
+    let __v_177: G = (__v_176 * __v_128);
+    let __v_178: G = G::from_u64(65536);
+    let __v_179: G = (__v_178 * __v_129);
+    let __v_180: G = G::from_u64(16777216);
+    let __v_181: G = (__v_180 * __v_130);
+    let __v_182: G = (__v_179 + __v_181);
+    let __v_183: G = (__v_177 + __v_182);
+    let __v_184: G = (__v_127 + __v_183);
+    let __v_185: G = G::from_u64(256);
+    let __v_186: G = (__v_185 * __v_132);
+    let __v_187: G = G::from_u64(65536);
+    let __v_188: G = (__v_187 * __v_133);
+    let __v_189: G = G::from_u64(16777216);
+    let __v_190: G = (__v_189 * __v_134);
+    let __v_191: G = (__v_188 + __v_190);
+    let __v_192: G = (__v_186 + __v_191);
+    let __v_193: G = (__v_131 + __v_192);
+    let __v_194: G = G::from_u64(256);
+    let __v_195: G = (__v_194 * __v_136);
+    let __v_196: G = G::from_u64(65536);
+    let __v_197: G = (__v_196 * __v_137);
+    let __v_198: G = G::from_u64(16777216);
+    let __v_199: G = (__v_198 * __v_138);
+    let __v_200: G = (__v_197 + __v_199);
+    let __v_201: G = (__v_195 + __v_200);
+    let __v_202: G = (__v_135 + __v_201);
+    let __v_203: G = G::from_u64(256);
+    let __v_204: G = (__v_203 * __v_140);
+    let __v_205: G = G::from_u64(65536);
+    let __v_206: G = (__v_205 * __v_141);
+    let __v_207: G = G::from_u64(16777216);
+    let __v_208: G = (__v_207 * __v_142);
+    let __v_209: G = (__v_206 + __v_208);
+    let __v_210: G = (__v_204 + __v_209);
+    let __v_211: G = (__v_139 + __v_210);
+    let __v_212: G = G::from_u64(256);
+    let __v_213: G = (__v_212 * __v_144);
+    let __v_214: G = G::from_u64(65536);
+    let __v_215: G = (__v_214 * __v_145);
+    let __v_216: G = G::from_u64(16777216);
+    let __v_217: G = (__v_216 * __v_146);
+    let __v_218: G = (__v_215 + __v_217);
+    let __v_219: G = (__v_213 + __v_218);
+    let __v_220: G = (__v_143 + __v_219);
+    let __v_221: G = G::from_u64(256);
+    let __v_222: G = (__v_221 * __v_148);
+    let __v_223: G = G::from_u64(65536);
+    let __v_224: G = (__v_223 * __v_149);
+    let __v_225: G = G::from_u64(16777216);
+    let __v_226: G = (__v_225 * __v_150);
+    let __v_227: G = (__v_224 + __v_226);
+    let __v_228: G = (__v_222 + __v_227);
+    let __v_229: G = (__v_147 + __v_228);
+    if (__v_166 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_175 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_175.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_184 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_193 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_193.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_202 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_202.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_211 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_211.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_220 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    if (__v_229 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) });
+    }
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_151, __v_154]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_230: G = __r_arr[0];
+    let __v_231: G = G::from_u64(1);
+    if (__v_230 != __v_231) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_231.as_canonical_u64(), msg: Some("aggr structural: output subject root is not nodeHash(left, right)".to_string()) });
+    }
+    let __ret: [G; OUT_241] = [];
+    if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_242: usize = 16;
+const IN_242: usize = 16;
+const OUT_242: usize = 0;
+fn aiur_fn_242(
+  inp: [G; IN_242],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_242], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = G::from_u64(3);
+    let __v_17: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_18: G = __io_pair.0;
+    let __v_19: G = __io_pair.1;
+    let __v_20: G = G::from_u64(3);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; 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_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(103);
+    let __v_23: G = G::from_u64(230);
+    let __v_24: G = G::from_u64(9);
+    let __v_25: G = G::from_u64(106);
+    let __v_26: G = G::from_u64(133);
+    let __v_27: G = G::from_u64(174);
+    let __v_28: G = G::from_u64(103);
+    let __v_29: G = G::from_u64(187);
+    let __v_30: G = G::from_u64(114);
+    let __v_31: G = G::from_u64(243);
+    let __v_32: G = G::from_u64(110);
+    let __v_33: G = G::from_u64(60);
+    let __v_34: G = G::from_u64(58);
+    let __v_35: G = G::from_u64(245);
+    let __v_36: G = G::from_u64(79);
+    let __v_37: G = G::from_u64(165);
+    let __v_38: G = G::from_u64(127);
+    let __v_39: G = G::from_u64(82);
+    let __v_40: G = G::from_u64(14);
+    let __v_41: G = G::from_u64(81);
+    let __v_42: G = G::from_u64(140);
+    let __v_43: G = G::from_u64(104);
+    let __v_44: G = G::from_u64(5);
+    let __v_45: G = G::from_u64(155);
+    let __v_46: G = G::from_u64(171);
+    let __v_47: G = G::from_u64(217);
+    let __v_48: G = G::from_u64(131);
+    let __v_49: G = G::from_u64(31);
+    let __v_50: G = G::from_u64(25);
+    let __v_51: G = G::from_u64(205);
+    let __v_52: G = G::from_u64(224);
+    let __v_53: G = G::from_u64(91);
+    let __v_54: G = G::from_u64(1);
+    let __v_55: G = G::from_u64(1);
+    let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = G::from_u64(0);
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = G::from_u64(1);
+    let __v_70: G = G::from_u64(1);
+    let __v_71: G = { let __values: [G; 34] = [__v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    let __v_75: G = __r_arr[2];
+    let __v_76: G = __r_arr[3];
+    let __v_77: G = __r_arr[4];
+    let __v_78: G = __r_arr[5];
+    let __v_79: G = __r_arr[6];
+    let __v_80: G = __r_arr[7];
+    let __v_81: G = __r_arr[8];
+    let __v_82: G = __r_arr[9];
+    let __v_83: G = __r_arr[10];
+    let __v_84: G = __r_arr[11];
+    let __v_85: G = __r_arr[12];
+    let __v_86: G = __r_arr[13];
+    let __v_87: G = __r_arr[14];
+    let __v_88: G = __r_arr[15];
+    let __v_89: G = __r_arr[16];
+    let __v_90: G = __r_arr[17];
+    let __v_91: G = __r_arr[18];
+    let __v_92: G = __r_arr[19];
+    let __v_93: G = __r_arr[20];
+    let __v_94: G = __r_arr[21];
+    let __v_95: G = __r_arr[22];
+    let __v_96: G = __r_arr[23];
+    let __v_97: G = __r_arr[24];
+    let __v_98: G = __r_arr[25];
+    let __v_99: G = __r_arr[26];
+    let __v_100: G = __r_arr[27];
+    let __v_101: G = __r_arr[28];
+    let __v_102: G = __r_arr[29];
+    let __v_103: G = __r_arr[30];
+    let __v_104: G = __r_arr[31];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_21]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_122]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_105]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __v_143: G = __r_arr[2];
+    let __v_144: G = __r_arr[3];
+    let __v_145: G = __r_arr[4];
+    let __v_146: G = __r_arr[5];
+    let __v_147: G = __r_arr[6];
+    let __v_148: G = __r_arr[7];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_123]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_149: G = __r_arr[0];
+    let __v_150: G = __r_arr[1];
+    let __v_151: G = __r_arr[2];
+    let __v_152: G = __r_arr[3];
+    let __v_153: G = __r_arr[4];
+    let __v_154: G = __r_arr[5];
+    let __v_155: G = __r_arr[6];
+    let __v_156: G = __r_arr[7];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_157: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_158: G = __r_arr[0];
+    let __v_159: G = G::from_u64(6);
+    let __v_160: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_160]; let __info = io_buffer.get_info(__v_159, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_161: G = __io_pair.0;
+    let __v_162: G = __io_pair.1;
+    let __v_163: G = G::from_u64(6);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_163, __v_161, __v_162]; 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_164: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_165: G = __r_arr[0];
+    let __v_166: G = __r_arr[1];
+    let __v_167: G = G::from_u64(80);
+    if (__v_19 != __v_167) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_167.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) });
+    }
+    let __v_168: G = G::from_u64(256);
+    let __v_169: G = (__v_168 * __v_74);
+    let __v_170: G = G::from_u64(65536);
+    let __v_171: G = (__v_170 * __v_75);
+    let __v_172: G = G::from_u64(16777216);
+    let __v_173: G = (__v_172 * __v_76);
+    let __v_174: G = (__v_171 + __v_173);
+    let __v_175: G = (__v_169 + __v_174);
+    let __v_176: G = (__v_73 + __v_175);
+    let __v_177: G = G::from_u64(256);
+    let __v_178: G = (__v_177 * __v_78);
+    let __v_179: G = G::from_u64(65536);
+    let __v_180: G = (__v_179 * __v_79);
+    let __v_181: G = G::from_u64(16777216);
+    let __v_182: G = (__v_181 * __v_80);
+    let __v_183: G = (__v_180 + __v_182);
+    let __v_184: G = (__v_178 + __v_183);
+    let __v_185: G = (__v_77 + __v_184);
+    let __v_186: G = G::from_u64(256);
+    let __v_187: G = (__v_186 * __v_82);
+    let __v_188: G = G::from_u64(65536);
+    let __v_189: G = (__v_188 * __v_83);
+    let __v_190: G = G::from_u64(16777216);
+    let __v_191: G = (__v_190 * __v_84);
+    let __v_192: G = (__v_189 + __v_191);
+    let __v_193: G = (__v_187 + __v_192);
+    let __v_194: G = (__v_81 + __v_193);
+    let __v_195: G = G::from_u64(256);
+    let __v_196: G = (__v_195 * __v_86);
+    let __v_197: G = G::from_u64(65536);
+    let __v_198: G = (__v_197 * __v_87);
+    let __v_199: G = G::from_u64(16777216);
+    let __v_200: G = (__v_199 * __v_88);
+    let __v_201: G = (__v_198 + __v_200);
+    let __v_202: G = (__v_196 + __v_201);
+    let __v_203: G = (__v_85 + __v_202);
+    let __v_204: G = G::from_u64(256);
+    let __v_205: G = (__v_204 * __v_90);
+    let __v_206: G = G::from_u64(65536);
+    let __v_207: G = (__v_206 * __v_91);
+    let __v_208: G = G::from_u64(16777216);
+    let __v_209: G = (__v_208 * __v_92);
+    let __v_210: G = (__v_207 + __v_209);
+    let __v_211: G = (__v_205 + __v_210);
+    let __v_212: G = (__v_89 + __v_211);
+    let __v_213: G = G::from_u64(256);
+    let __v_214: G = (__v_213 * __v_94);
+    let __v_215: G = G::from_u64(65536);
+    let __v_216: G = (__v_215 * __v_95);
+    let __v_217: G = G::from_u64(16777216);
+    let __v_218: G = (__v_217 * __v_96);
+    let __v_219: G = (__v_216 + __v_218);
+    let __v_220: G = (__v_214 + __v_219);
+    let __v_221: G = (__v_93 + __v_220);
+    let __v_222: G = G::from_u64(256);
+    let __v_223: G = (__v_222 * __v_98);
+    let __v_224: G = G::from_u64(65536);
+    let __v_225: G = (__v_224 * __v_99);
+    let __v_226: G = G::from_u64(16777216);
+    let __v_227: G = (__v_226 * __v_100);
+    let __v_228: G = (__v_225 + __v_227);
+    let __v_229: G = (__v_223 + __v_228);
+    let __v_230: G = (__v_97 + __v_229);
+    let __v_231: G = G::from_u64(256);
+    let __v_232: G = (__v_231 * __v_102);
+    let __v_233: G = G::from_u64(65536);
+    let __v_234: G = (__v_233 * __v_103);
+    let __v_235: G = G::from_u64(16777216);
+    let __v_236: G = (__v_235 * __v_104);
+    let __v_237: G = (__v_234 + __v_236);
+    let __v_238: G = (__v_232 + __v_237);
+    let __v_239: G = (__v_101 + __v_238);
+    if (__v_176 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_176.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_185 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_194 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_194.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_203 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_203.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_212 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_212.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_221 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_221.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_230 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_239 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_140.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_240: G = __loaded[0];
+    let __v_241: G = __loaded[1];
+    let __v_242: G = __loaded[2];
+    let __v_243: G = G::from_u64(1);
+    let __v_244: G = G::from_u64(1);
+    if (__v_240 != __v_243) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_243.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) });
+    }
+    if (__v_241 != __v_244) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_244.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) });
+    }
+    if (__v_242 != __v_244) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_244.as_canonical_u64(), msg: Some("aggr: allowed blob must be exactly 80 bytes".to_string()) });
+    }
+    let __v_245: G = G::from_u64(1);
+    if (__v_162 != __v_245) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_245.as_canonical_u64(), msg: Some("aggr: shape hint must be exactly one byte".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_166.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_246: G = __loaded[0];
+    let __v_247: G = __loaded[1];
+    let __v_248: G = __loaded[2];
+    let __v_249: G = G::from_u64(1);
+    let __v_250: G = G::from_u64(1);
+    if (__v_246 != __v_249) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_246.as_canonical_u64(), rhs: __v_249.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) });
+    }
+    if (__v_247 != __v_250) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_247.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) });
+    }
+    if (__v_248 != __v_250) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_248.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("aggr: trailing bytes after shape hint".to_string()) });
+    }
+    match __v_165.as_canonical_u64() {
+      0u64 => {
+        let __v_251: G = G::from_u64(0);
+        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_251: G = G::from_u64(0);
+        let __v_252: G = G::from_u64(0);
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_251: G = G::from_u64(0);
+        let __v_252: G = G::from_u64(1);
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __v_252: G = G::from_u64(0);
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __v_252: G = G::from_u64(1);
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_251: G = G::from_u64(0);
+        let __v_252: G = G::from_u64(0);
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_251: G = G::from_u64(0);
+        let __v_252: G = G::from_u64(1);
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __v_252: G = G::from_u64(0);
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_251: G = G::from_u64(1);
+        let __v_252: G = G::from_u64(1);
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __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[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_242] = [];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_165.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_243: usize = 2;
+const IN_243: usize = 2;
+const OUT_243: usize = 1;
+fn aiur_fn_243(
+  inp: [G; IN_243],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_243], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_243] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_244: usize = 1;
+const IN_244: usize = 1;
+const OUT_244: usize = 1;
+fn aiur_fn_244(
+  inp: [G; IN_244],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_244], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_244] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_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_244] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_245: usize = 1;
+const IN_245: usize = 1;
+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_245], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_245] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_245] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_246: usize = 2;
+const IN_246: usize = 2;
+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_246], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_246] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_1]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_246] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_247], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_247] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__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 { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } 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_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_247] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_248: usize = 1;
+const IN_248: usize = 1;
+const OUT_248: usize = 1;
+fn aiur_fn_248(
+  inp: [G; IN_248],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_248], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_248] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+        let __v_10: G = (__v_8 + __v_9);
+        let __ret: [G; OUT_248] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_249: usize = 1;
+const IN_249: usize = 1;
+const OUT_249: usize = 1;
+fn aiur_fn_249(
+  inp: [G; IN_249],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_249], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_11: G = G::from_u64(0);
+        let __ret: [G; OUT_249] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_10]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_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_249] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_250: usize = 2;
+const IN_250: usize = 2;
+const OUT_250: usize = 4;
+fn aiur_fn_250(
+  inp: [G; IN_250],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_250], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; 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 { let __r = record.function_queries[259].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_250] = [__v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_251: usize = 1;
+const IN_251: usize = 1;
+const OUT_251: usize = 1;
+fn aiur_fn_251(
+  inp: [G; IN_251],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_251], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_251] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_251] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_252: usize = 2;
+const IN_252: usize = 2;
+const OUT_252: usize = 2;
+fn aiur_fn_252(
+  inp: [G; IN_252],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_252], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; 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 { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_252] = [__v_4, __v_5];
+        if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_253: usize = 2;
+const IN_253: usize = 2;
+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_253], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_253] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11, __v_1]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_253] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_254: usize = 1;
+const IN_254: usize = 1;
+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_254], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_254] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_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_254] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_255: usize = 2;
+const IN_255: usize = 2;
+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_255], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_255] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_255] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_256: usize = 1;
+const IN_256: usize = 1;
+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_256], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_256] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = (__v_9 + __v_10);
+        let __ret: [G; OUT_256] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_257: usize = 2;
+const IN_257: usize = 2;
+const OUT_257: usize = 8;
+fn aiur_fn_257(
+  inp: [G; IN_257],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_257], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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 { let __r = record.function_queries[260].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_257] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_258: usize = 2;
+const IN_258: usize = 2;
+const OUT_258: usize = 1;
+fn aiur_fn_258(
+  inp: [G; IN_258],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_258], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_258] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __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 { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_258] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_259: usize = 2;
+const IN_259: usize = 2;
+const OUT_259: usize = 1;
+fn aiur_fn_259(
+  inp: [G; IN_259],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_259], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_259] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; 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 { let __r = record.function_queries[259].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_259] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+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_260], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_260] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __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 { let __r = record.function_queries[260].replay_at(__i); record.virt += __r; } 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_4: 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_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: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_260] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
+  })
+}
+
+pub(crate) fn execute_generated(
+  fun_idx: usize,
+  args: &[G],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+) -> Result<Vec<G>, ExecError> {
+  match fun_idx as u64 {
+    0u64 => {
+      let __inp: [G; IN_0] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_0(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    1u64 => {
+      let __inp: [G; IN_1] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_1(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    2u64 => {
+      let __inp: [G; IN_2] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_2(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    3u64 => {
+      let __inp: [G; IN_3] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_3(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    4u64 => {
+      let __inp: [G; IN_4] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_4(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    5u64 => {
+      let __inp: [G; IN_5] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_5(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    6u64 => {
+      let __inp: [G; IN_6] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_6(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    7u64 => {
+      let __inp: [G; IN_7] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_7(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    8u64 => {
+      let __inp: [G; IN_8] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_8(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    9u64 => {
+      let __inp: [G; IN_9] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_9(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    10u64 => {
+      let __inp: [G; IN_10] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_10(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    11u64 => {
+      let __inp: [G; IN_11] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_11(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    12u64 => {
+      let __inp: [G; IN_12] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_12(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    13u64 => {
+      let __inp: [G; IN_13] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_13(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    14u64 => {
+      let __inp: [G; IN_14] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_14(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    15u64 => {
+      let __inp: [G; IN_15] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_15(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    16u64 => {
+      let __inp: [G; IN_16] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_16(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    17u64 => {
+      let __inp: [G; IN_17] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_17(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    18u64 => {
+      let __inp: [G; IN_18] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_18(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    19u64 => {
+      let __inp: [G; IN_19] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_19(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    20u64 => {
+      let __inp: [G; IN_20] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_20(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    21u64 => {
+      let __inp: [G; IN_21] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_21(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    22u64 => {
+      let __inp: [G; IN_22] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_22(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    23u64 => {
+      let __inp: [G; IN_23] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_23(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    24u64 => {
+      let __inp: [G; IN_24] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_24(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    25u64 => {
+      let __inp: [G; IN_25] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_25(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    26u64 => {
+      let __inp: [G; IN_26] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_26(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    27u64 => {
+      let __inp: [G; IN_27] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_27(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    28u64 => {
+      let __inp: [G; IN_28] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_28(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    29u64 => {
+      let __inp: [G; IN_29] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_29(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    30u64 => {
+      let __inp: [G; IN_30] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_30(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    31u64 => {
+      let __inp: [G; IN_31] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_31(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    32u64 => {
+      let __inp: [G; IN_32] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_32(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    33u64 => {
+      let __inp: [G; IN_33] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_33(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    34u64 => {
+      let __inp: [G; IN_34] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_34(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    35u64 => {
+      let __inp: [G; IN_35] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_35(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    36u64 => {
+      let __inp: [G; IN_36] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_36(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    37u64 => {
+      let __inp: [G; IN_37] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_37(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    38u64 => {
+      let __inp: [G; IN_38] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_38(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    39u64 => {
+      let __inp: [G; IN_39] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_39(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    40u64 => {
+      let __inp: [G; IN_40] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_40(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    41u64 => {
+      let __inp: [G; IN_41] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_41(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    42u64 => {
+      let __inp: [G; IN_42] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_42(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    43u64 => {
+      let __inp: [G; IN_43] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_43(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    44u64 => {
+      let __inp: [G; IN_44] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_44(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    45u64 => {
+      let __inp: [G; IN_45] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_45(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    46u64 => {
+      let __inp: [G; IN_46] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_46(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    47u64 => {
+      let __inp: [G; IN_47] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_47(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    48u64 => {
+      let __inp: [G; IN_48] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_48(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    49u64 => {
+      let __inp: [G; IN_49] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_49(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    50u64 => {
+      let __inp: [G; IN_50] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_50(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    51u64 => {
+      let __inp: [G; IN_51] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_51(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    52u64 => {
+      let __inp: [G; IN_52] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_52(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    53u64 => {
+      let __inp: [G; IN_53] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_53(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    54u64 => {
+      let __inp: [G; IN_54] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_54(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    55u64 => {
+      let __inp: [G; IN_55] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_55(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    56u64 => {
+      let __inp: [G; IN_56] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_56(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    57u64 => {
+      let __inp: [G; IN_57] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_57(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    58u64 => {
+      let __inp: [G; IN_58] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_58(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    59u64 => {
+      let __inp: [G; IN_59] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_59(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    60u64 => {
+      let __inp: [G; IN_60] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_60(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    61u64 => {
+      let __inp: [G; IN_61] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_61(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    62u64 => {
+      let __inp: [G; IN_62] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_62(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    63u64 => {
+      let __inp: [G; IN_63] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_63(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    64u64 => {
+      let __inp: [G; IN_64] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_64(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    65u64 => {
+      let __inp: [G; IN_65] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_65(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    66u64 => {
+      let __inp: [G; IN_66] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_66(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    67u64 => {
+      let __inp: [G; IN_67] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_67(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    68u64 => {
+      let __inp: [G; IN_68] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_68(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    69u64 => {
+      let __inp: [G; IN_69] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_69(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    70u64 => {
+      let __inp: [G; IN_70] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_70(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    71u64 => {
+      let __inp: [G; IN_71] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_71(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    72u64 => {
+      let __inp: [G; IN_72] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_72(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    73u64 => {
+      let __inp: [G; IN_73] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_73(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    74u64 => {
+      let __inp: [G; IN_74] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_74(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    75u64 => {
+      let __inp: [G; IN_75] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_75(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    76u64 => {
+      let __inp: [G; IN_76] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_76(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    77u64 => {
+      let __inp: [G; IN_77] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_77(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    78u64 => {
+      let __inp: [G; IN_78] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_78(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    79u64 => {
+      let __inp: [G; IN_79] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_79(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    80u64 => {
+      let __inp: [G; IN_80] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_80(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    81u64 => {
+      let __inp: [G; IN_81] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_81(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    82u64 => {
+      let __inp: [G; IN_82] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_82(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    83u64 => {
+      let __inp: [G; IN_83] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_83(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    84u64 => {
+      let __inp: [G; IN_84] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_84(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    85u64 => {
+      let __inp: [G; IN_85] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_85(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    86u64 => {
+      let __inp: [G; IN_86] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_86(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    87u64 => {
+      let __inp: [G; IN_87] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_87(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    88u64 => {
+      let __inp: [G; IN_88] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_88(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    89u64 => {
+      let __inp: [G; IN_89] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_89(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    90u64 => {
+      let __inp: [G; IN_90] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_90(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    91u64 => {
+      let __inp: [G; IN_91] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_91(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    92u64 => {
+      let __inp: [G; IN_92] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_92(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    93u64 => {
+      let __inp: [G; IN_93] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_93(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    94u64 => {
+      let __inp: [G; IN_94] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_94(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    95u64 => {
+      let __inp: [G; IN_95] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_95(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    96u64 => {
+      let __inp: [G; IN_96] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_96(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    97u64 => {
+      let __inp: [G; IN_97] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_97(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    98u64 => {
+      let __inp: [G; IN_98] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_98(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    99u64 => {
+      let __inp: [G; IN_99] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_99(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    100u64 => {
+      let __inp: [G; IN_100] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_100(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    101u64 => {
+      let __inp: [G; IN_101] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_101(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    102u64 => {
+      let __inp: [G; IN_102] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_102(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    103u64 => {
+      let __inp: [G; IN_103] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_103(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    104u64 => {
+      let __inp: [G; IN_104] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_104(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    105u64 => {
+      let __inp: [G; IN_105] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_105(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    106u64 => {
+      let __inp: [G; IN_106] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_106(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    107u64 => {
+      let __inp: [G; IN_107] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_107(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    108u64 => {
+      let __inp: [G; IN_108] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_108(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    109u64 => {
+      let __inp: [G; IN_109] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_109(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    110u64 => {
+      let __inp: [G; IN_110] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_110(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    111u64 => {
+      let __inp: [G; IN_111] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_111(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    112u64 => {
+      let __inp: [G; IN_112] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_112(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    113u64 => {
+      let __inp: [G; IN_113] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_113(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    114u64 => {
+      let __inp: [G; IN_114] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_114(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    115u64 => {
+      let __inp: [G; IN_115] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_115(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    116u64 => {
+      let __inp: [G; IN_116] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_116(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    117u64 => {
+      let __inp: [G; IN_117] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_117(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    118u64 => {
+      let __inp: [G; IN_118] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_118(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    119u64 => {
+      let __inp: [G; IN_119] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_119(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    120u64 => {
+      let __inp: [G; IN_120] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_120(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    121u64 => {
+      let __inp: [G; IN_121] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_121(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    122u64 => {
+      let __inp: [G; IN_122] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_122(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    123u64 => {
+      let __inp: [G; IN_123] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_123(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    124u64 => {
+      let __inp: [G; IN_124] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_124(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    125u64 => {
+      let __inp: [G; IN_125] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_125(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    126u64 => {
+      let __inp: [G; IN_126] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_126(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    127u64 => {
+      let __inp: [G; IN_127] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_127(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    128u64 => {
+      let __inp: [G; IN_128] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_128(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    129u64 => {
+      let __inp: [G; IN_129] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_129(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    130u64 => {
+      let __inp: [G; IN_130] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_130(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    131u64 => {
+      let __inp: [G; IN_131] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_131(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    132u64 => {
+      let __inp: [G; IN_132] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_132(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    133u64 => {
+      let __inp: [G; IN_133] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_133(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    134u64 => {
+      let __inp: [G; IN_134] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_134(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    135u64 => {
+      let __inp: [G; IN_135] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_135(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    136u64 => {
+      let __inp: [G; IN_136] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_136(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    137u64 => {
+      let __inp: [G; IN_137] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_137(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    138u64 => {
+      let __inp: [G; IN_138] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_138(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    139u64 => {
+      let __inp: [G; IN_139] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_139(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    140u64 => {
+      let __inp: [G; IN_140] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_140(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    141u64 => {
+      let __inp: [G; IN_141] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_141(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    142u64 => {
+      let __inp: [G; IN_142] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_142(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    143u64 => {
+      let __inp: [G; IN_143] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_143(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    144u64 => {
+      let __inp: [G; IN_144] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_144(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    145u64 => {
+      let __inp: [G; IN_145] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_145(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    146u64 => {
+      let __inp: [G; IN_146] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_146(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    147u64 => {
+      let __inp: [G; IN_147] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_147(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    148u64 => {
+      let __inp: [G; IN_148] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_148(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    149u64 => {
+      let __inp: [G; IN_149] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_149(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    150u64 => {
+      let __inp: [G; IN_150] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_150(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    151u64 => {
+      let __inp: [G; IN_151] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_151(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    152u64 => {
+      let __inp: [G; IN_152] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_152(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    153u64 => {
+      let __inp: [G; IN_153] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_153(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    154u64 => {
+      let __inp: [G; IN_154] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_154(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    155u64 => {
+      let __inp: [G; IN_155] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_155(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    156u64 => {
+      let __inp: [G; IN_156] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_156(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    157u64 => {
+      let __inp: [G; IN_157] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_157(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    158u64 => {
+      let __inp: [G; IN_158] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_158(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    159u64 => {
+      let __inp: [G; IN_159] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_159(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    160u64 => {
+      let __inp: [G; IN_160] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_160(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    161u64 => {
+      let __inp: [G; IN_161] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_161(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    162u64 => {
+      let __inp: [G; IN_162] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_162(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    163u64 => {
+      let __inp: [G; IN_163] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_163(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    164u64 => {
+      let __inp: [G; IN_164] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_164(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    165u64 => {
+      let __inp: [G; IN_165] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_165(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    166u64 => {
+      let __inp: [G; IN_166] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_166(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    167u64 => {
+      let __inp: [G; IN_167] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_167(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    168u64 => {
+      let __inp: [G; IN_168] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_168(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    169u64 => {
+      let __inp: [G; IN_169] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_169(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    170u64 => {
+      let __inp: [G; IN_170] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_170(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    171u64 => {
+      let __inp: [G; IN_171] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_171(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    172u64 => {
+      let __inp: [G; IN_172] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_172(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    173u64 => {
+      let __inp: [G; IN_173] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_173(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    174u64 => {
+      let __inp: [G; IN_174] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_174(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    175u64 => {
+      let __inp: [G; IN_175] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_175(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    176u64 => {
+      let __inp: [G; IN_176] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_176(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    177u64 => {
+      let __inp: [G; IN_177] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_177(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    178u64 => {
+      let __inp: [G; IN_178] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_178(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    179u64 => {
+      let __inp: [G; IN_179] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_179(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    180u64 => {
+      let __inp: [G; IN_180] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_180(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    181u64 => {
+      let __inp: [G; IN_181] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_181(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    182u64 => {
+      let __inp: [G; IN_182] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_182(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    183u64 => {
+      let __inp: [G; IN_183] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_183(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    184u64 => {
+      let __inp: [G; IN_184] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_184(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    185u64 => {
+      let __inp: [G; IN_185] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_185(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    186u64 => {
+      let __inp: [G; IN_186] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_186(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    187u64 => {
+      let __inp: [G; IN_187] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_187(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    188u64 => {
+      let __inp: [G; IN_188] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_188(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    189u64 => {
+      let __inp: [G; IN_189] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_189(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    190u64 => {
+      let __inp: [G; IN_190] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_190(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    191u64 => {
+      let __inp: [G; IN_191] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_191(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    192u64 => {
+      let __inp: [G; IN_192] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_192(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    193u64 => {
+      let __inp: [G; IN_193] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_193(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    194u64 => {
+      let __inp: [G; IN_194] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_194(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    195u64 => {
+      let __inp: [G; IN_195] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_195(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    196u64 => {
+      let __inp: [G; IN_196] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_196(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    197u64 => {
+      let __inp: [G; IN_197] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_197(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    198u64 => {
+      let __inp: [G; IN_198] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_198(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    199u64 => {
+      let __inp: [G; IN_199] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_199(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    200u64 => {
+      let __inp: [G; IN_200] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_200(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    201u64 => {
+      let __inp: [G; IN_201] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_201(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    202u64 => {
+      let __inp: [G; IN_202] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_202(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    203u64 => {
+      let __inp: [G; IN_203] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_203(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    204u64 => {
+      let __inp: [G; IN_204] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_204(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    205u64 => {
+      let __inp: [G; IN_205] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_205(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    206u64 => {
+      let __inp: [G; IN_206] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_206(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    207u64 => {
+      let __inp: [G; IN_207] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_207(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    208u64 => {
+      let __inp: [G; IN_208] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_208(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    209u64 => {
+      let __inp: [G; IN_209] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_209(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    210u64 => {
+      let __inp: [G; IN_210] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_210(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    211u64 => {
+      let __inp: [G; IN_211] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_211(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    212u64 => {
+      let __inp: [G; IN_212] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_212(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    213u64 => {
+      let __inp: [G; IN_213] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_213(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    214u64 => {
+      let __inp: [G; IN_214] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_214(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    215u64 => {
+      let __inp: [G; IN_215] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_215(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    216u64 => {
+      let __inp: [G; IN_216] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_216(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    217u64 => {
+      let __inp: [G; IN_217] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_217(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    218u64 => {
+      let __inp: [G; IN_218] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_218(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    219u64 => {
+      let __inp: [G; IN_219] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_219(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    220u64 => {
+      let __inp: [G; IN_220] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_220(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    221u64 => {
+      let __inp: [G; IN_221] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_221(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    222u64 => {
+      let __inp: [G; IN_222] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_222(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    223u64 => {
+      let __inp: [G; IN_223] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_223(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    224u64 => {
+      let __inp: [G; IN_224] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_224(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    225u64 => {
+      let __inp: [G; IN_225] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_225(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    226u64 => {
+      let __inp: [G; IN_226] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_226(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    227u64 => {
+      let __inp: [G; IN_227] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_227(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    228u64 => {
+      let __inp: [G; IN_228] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_228(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    229u64 => {
+      let __inp: [G; IN_229] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_229(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    230u64 => {
+      let __inp: [G; IN_230] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_230(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    231u64 => {
+      let __inp: [G; IN_231] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_231(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    232u64 => {
+      let __inp: [G; IN_232] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_232(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    233u64 => {
+      let __inp: [G; IN_233] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_233(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    234u64 => {
+      let __inp: [G; IN_234] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_234(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    235u64 => {
+      let __inp: [G; IN_235] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_235(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    236u64 => {
+      let __inp: [G; IN_236] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_236(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    237u64 => {
+      let __inp: [G; IN_237] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_237(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    238u64 => {
+      let __inp: [G; IN_238] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_238(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    239u64 => {
+      let __inp: [G; IN_239] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_239(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    240u64 => {
+      let __inp: [G; IN_240] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_240(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    241u64 => {
+      let __inp: [G; IN_241] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_241(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    242u64 => {
+      let __inp: [G; IN_242] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_242(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    243u64 => {
+      let __inp: [G; IN_243] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_243(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    244u64 => {
+      let __inp: [G; IN_244] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_244(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    245u64 => {
+      let __inp: [G; IN_245] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_245(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    246u64 => {
+      let __inp: [G; IN_246] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_246(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    247u64 => {
+      let __inp: [G; IN_247] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_247(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    248u64 => {
+      let __inp: [G; IN_248] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_248(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    249u64 => {
+      let __inp: [G; IN_249] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_249(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    250u64 => {
+      let __inp: [G; IN_250] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_250(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    251u64 => {
+      let __inp: [G; IN_251] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_251(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    252u64 => {
+      let __inp: [G; IN_252] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_252(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    253u64 => {
+      let __inp: [G; IN_253] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_253(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    254u64 => {
+      let __inp: [G; IN_254] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_254(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    255u64 => {
+      let __inp: [G; IN_255] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_255(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    256u64 => {
+      let __inp: [G; IN_256] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_256(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    257u64 => {
+      let __inp: [G; IN_257] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_257(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    258u64 => {
+      let __inp: [G; IN_258] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_258(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    259u64 => {
+      let __inp: [G; IN_259] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_259(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    260u64 => {
+      let __inp: [G; IN_260] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_260(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    _ => {
+      return Err(ExecError::InvalidFunIdx(fun_idx));
+    },
+  }
+}
diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs
new file mode 100644
index 000000000..9973d25bb
--- /dev/null
+++ b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs
@@ -0,0 +1,368 @@
+//! ixAggr-native execute path.
+//!
+//! Mirror of `aiur_multi_stark_runner` for the `ixAggr` toplevel: routes the
+//! Aiur fn invocation through the codegen'd Rust aggregator
+//! (`crate::aiur_ix_aggr::execute_generated`) instead of the interpreter,
+//! with the same `QueryRecord` shape, multiplicity rules, and IO side
+//! effects, so the trace produced here is byte-for-byte identical to the
+//! interpreter's (modulo the codegen parity invariant).
+//!
+//! Also home to `aggr_io_buffer`, the native builder for `ix_aggr`'s
+//! seven-channel IO advice, and the strict decoders for the compact keyed
+//! blob framing the Lean host uses to hand preimages and trees across FFI.
+
+use multi_stark::p3_field::PrimeCharacteristicRing;
+use rustc_hash::FxHashMap;
+
+use crate::aiur_ix_aggr::execute_generated;
+use aiur::G;
+use aiur::bytecode::{FunIdx, Toplevel};
+use aiur::execute::{ExecError, IOBuffer, IOKeyInfo, QueryRecord};
+
+/// One content-addressed `CheckEnv` preimage consumed by `ix_aggr` on IO
+/// channel 4. The digest is keyed in the packed-four-byte public-digest
+/// form; the circuit re-hashes `bytes` before using the decoded claim.
+#[derive(Clone, Copy, Debug)]
+pub struct AggrPreimage<'a> {
+  pub digest: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// One serialized canonical `AssumptionTree` consumed by `ix_aggr` on IO
+/// channel 5. Tree roots use the raw-address key representation: one field
+/// element per byte.
+#[derive(Clone, Copy, Debug)]
+pub struct AggrTree<'a> {
+  pub root: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// One carried/discharged choice consumed by structural `ix_aggr` shapes on
+/// IO channel 6. Candidates use the raw-address key representation; the
+/// circuit strictly parses each payload and verifies every discharge path.
+#[derive(Clone, Copy, Debug)]
+pub struct AggrPath<'a> {
+  pub candidate: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// Raw advice for one `ix_aggr` invocation, any shape.
+///
+/// Borrowed view: real proofs are multi-megabyte blobs, so constructing an
+/// IO buffer must not first clone the caller's byte arrays. `proof_advice`
+/// contains the expanded per-query transport, never compact proof wire bytes. Wrap shapes
+/// leave the right-child slots empty; the circuit never reads them.
+#[derive(Clone, Copy, Debug)]
+pub struct AggrAdvice<'a> {
+  pub shape: u8,
+  pub proof_advice: [&'a [u8]; 2],
+  pub ixvm_vk: &'a [u8],
+  pub self_vk: &'a [u8],
+  pub child_claims: [&'a [u8]; 2],
+  pub output_claim: &'a [u8],
+  pub allowed: &'a [u8],
+  pub preimages: &'a [AggrPreimage<'a>],
+  pub trees: &'a [AggrTree<'a>],
+  pub paths: &'a [AggrPath<'a>],
+}
+
+/// Decode the compact host/FFI representation of digest-addressed
+/// preimages. The wire format is a little-endian `u32` entry count followed
+/// by `(32-byte key, u32 payload length, payload)` entries.
+pub fn decode_aggr_preimages(
+  blob: &[u8],
+) -> Result<Vec<AggrPreimage<'_>>, String> {
+  decode_keyed_blobs(blob, "aggr preimages").map(|entries| {
+    entries
+      .into_iter()
+      .map(|(digest, bytes)| AggrPreimage { digest, bytes })
+      .collect()
+  })
+}
+
+/// Decode the compact host/FFI representation of root-addressed trees. Its
+/// framing is identical to [`decode_aggr_preimages`].
+pub fn decode_aggr_trees(blob: &[u8]) -> Result<Vec<AggrTree<'_>>, String> {
+  decode_keyed_blobs(blob, "aggr trees").map(|entries| {
+    entries.into_iter().map(|(root, bytes)| AggrTree { root, bytes }).collect()
+  })
+}
+
+/// Decode compact candidate-addressed structural-discharge choices. Framing
+/// is identical to [`decode_aggr_preimages`]; payload semantics are checked by
+/// the circuit.
+pub fn decode_aggr_paths(blob: &[u8]) -> Result<Vec<AggrPath<'_>>, String> {
+  decode_keyed_blobs(blob, "aggr paths").map(|entries| {
+    entries
+      .into_iter()
+      .map(|(candidate, bytes)| AggrPath { candidate, bytes })
+      .collect()
+  })
+}
+
+fn decode_keyed_blobs<'a>(
+  blob: &'a [u8],
+  label: &str,
+) -> Result<Vec<([u8; 32], &'a [u8])>, String> {
+  let mut cursor = 0usize;
+  let count = read_u32(blob, &mut cursor, label)? as usize;
+  let max_entries = blob.len().saturating_sub(cursor) / 36;
+  if count > max_entries {
+    return Err(format!(
+      "{label}: declares {count} entries, but the blob can contain at most \
+       {max_entries} complete key/length headers"
+    ));
+  }
+  let mut entries = Vec::with_capacity(count);
+  for entry_index in 0..count {
+    let key_end = cursor.checked_add(32).ok_or_else(|| {
+      format!("{label}: entry {entry_index} key offset overflow")
+    })?;
+    let key_slice = blob.get(cursor..key_end).ok_or_else(|| {
+      format!("{label}: truncated 32-byte key for entry {entry_index}")
+    })?;
+    let key: [u8; 32] =
+      key_slice.try_into().expect("slice length was checked above");
+    cursor = key_end;
+
+    let payload_len = read_u32(blob, &mut cursor, label)? as usize;
+    let payload_end = cursor.checked_add(payload_len).ok_or_else(|| {
+      format!("{label}: entry {entry_index} payload offset overflow")
+    })?;
+    let payload = blob.get(cursor..payload_end).ok_or_else(|| {
+      format!(
+        "{label}: entry {entry_index} declares {payload_len} payload bytes, \
+         but only {} remain",
+        blob.len().saturating_sub(cursor)
+      )
+    })?;
+    cursor = payload_end;
+    entries.push((key, payload));
+  }
+  if cursor != blob.len() {
+    return Err(format!(
+      "{label}: {} trailing bytes after {count} entries",
+      blob.len() - cursor
+    ));
+  }
+  Ok(entries)
+}
+
+fn read_u32(
+  blob: &[u8],
+  cursor: &mut usize,
+  label: &str,
+) -> Result<u32, String> {
+  let end = cursor
+    .checked_add(4)
+    .ok_or_else(|| format!("{label}: length offset overflow"))?;
+  let bytes: [u8; 4] = blob
+    .get(*cursor..end)
+    .ok_or_else(|| format!("{label}: truncated u32 length"))?
+    .try_into()
+    .expect("slice length was checked above");
+  *cursor = end;
+  Ok(u32::from_le_bytes(bytes))
+}
+
+/// Append one keyed byte stream to an IO channel arena.
+#[inline]
+fn extend_bytes(io: &mut IOBuffer, channel: G, key: Vec<G>, bytes: &[u8]) {
+  let arena = io.data.entry(channel).or_default();
+  let idx = arena.len();
+  let len = bytes.len();
+  arena.extend(bytes.iter().map(|b| G::from_u8(*b)));
+  io.map.insert((channel, key), IOKeyInfo { idx, len });
+}
+
+/// An integer stream index (`[0]`, `[1]`, or `[2]`) as an Aiur IO key.
+#[inline]
+fn index_key(index: u8) -> Vec<G> {
+  vec![G::from_u8(index)]
+}
+
+/// A Blake3 digest as eight packed little-endian `u32` field elements.
+/// Mirrors in-circuit `b3_pack` and Lean `Aggr.digestGs`.
+#[inline]
+fn packed_digest_key(digest: &[u8; 32]) -> Vec<G> {
+  digest
+    .as_chunks::<4>()
+    .0
+    .iter()
+    .map(|word| G::from_u32(u32::from_le_bytes(*word)))
+    .collect()
+}
+
+/// A 32-byte address as 32 field elements, matching the tree-loader key.
+#[inline]
+fn address_key(address: &[u8; 32]) -> Vec<G> {
+  address.iter().map(|b| G::from_u8(*b)).collect()
+}
+
+/// Mirror of `Toplevel::execute` (same return shape, same `entry`-flag
+/// gate), but routes execution through the codegen'd Rust aggregator. Deep
+/// recursion is handled via per-fn `stacker::maybe_grow` checks in the
+/// generated code.
+// `args: Vec<G>` mirrors `Toplevel::execute`'s signature so this fn can be
+// used as an `impl Fn(&Toplevel, _, Vec<G>, _) -> _` in
+// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound.
+#[allow(clippy::needless_pass_by_value)]
+pub fn execute_ix_aggr(
+  toplevel: &Toplevel,
+  fun_idx: FunIdx,
+  args: Vec<G>,
+  io_buffer: &mut IOBuffer,
+) -> Result<(QueryRecord, Vec<G>), ExecError> {
+  if !toplevel.functions[fun_idx].entry {
+    return Err(ExecError::NotEntryFunction(fun_idx));
+  }
+  let mut record = QueryRecord::new(toplevel, false);
+  let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?;
+  Ok((record, output))
+}
+
+/// Build `ix_aggr`'s seven-channel IO advice buffer.
+///
+/// Layout (the circuit binds every digest-addressed blob before decoding):
+///
+/// * ch 0 `[0]`, `[1]`: left/right expanded child proof advice;
+/// * ch 1 `[0]`, `[1]`: the IxVM and self verifying keys, by child kind;
+/// * ch 2 `[0]`, `[1]`, `[2]`: child claims and the output `CheckEnv` claim;
+/// * ch 3 `[0]`: the digest-bound 80-byte allowed blob;
+/// * ch 4 `packed(blake3)`: `CheckEnv` claim preimages;
+/// * ch 5 `root bytes`: serialized canonical assumption trees;
+/// * ch 6 `[0]`: the one-byte shape hint;
+/// * ch 6 `candidate bytes`: structural carried/discharged choices and paths.
+pub fn aggr_io_buffer(advice: &AggrAdvice<'_>) -> IOBuffer {
+  let mut io =
+    IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() };
+
+  extend_bytes(&mut io, G::from_u8(0), index_key(0), advice.proof_advice[0]);
+  extend_bytes(&mut io, G::from_u8(0), index_key(1), advice.proof_advice[1]);
+  extend_bytes(&mut io, G::from_u8(1), index_key(0), advice.ixvm_vk);
+  extend_bytes(&mut io, G::from_u8(1), index_key(1), advice.self_vk);
+  extend_bytes(&mut io, G::from_u8(2), index_key(0), advice.child_claims[0]);
+  extend_bytes(&mut io, G::from_u8(2), index_key(1), advice.child_claims[1]);
+  extend_bytes(&mut io, G::from_u8(2), index_key(2), advice.output_claim);
+  extend_bytes(&mut io, G::from_u8(3), index_key(0), advice.allowed);
+
+  for preimage in advice.preimages {
+    extend_bytes(
+      &mut io,
+      G::from_u8(4),
+      packed_digest_key(&preimage.digest),
+      preimage.bytes,
+    );
+  }
+  for tree in advice.trees {
+    extend_bytes(&mut io, G::from_u8(5), address_key(&tree.root), tree.bytes);
+  }
+  extend_bytes(&mut io, G::from_u8(6), index_key(0), &[advice.shape]);
+  for path in advice.paths {
+    extend_bytes(
+      &mut io,
+      G::from_u8(6),
+      address_key(&path.candidate),
+      path.bytes,
+    );
+  }
+
+  io
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use multi_stark::p3_field::PrimeField64;
+
+  fn info(io: &IOBuffer, channel: u8, key: Vec<G>) -> (usize, usize) {
+    let info =
+      io.map.get(&(G::from_u8(channel), key)).expect("missing IO mapping");
+    (info.idx, info.len)
+  }
+
+  fn arena_bytes(io: &IOBuffer, channel: u8) -> Vec<u8> {
+    io.data[&G::from_u8(channel)]
+      .iter()
+      .map(|g| u8::try_from(g.as_canonical_u64()).expect("IO test byte"))
+      .collect()
+  }
+
+  #[test]
+  fn aggr_layout_indexes_streams_and_uses_both_digest_key_encodings() {
+    let mut digest = [0u8; 32];
+    for (i, byte) in digest.iter_mut().enumerate() {
+      *byte = u8::try_from(i).expect("32-byte index");
+    }
+    let mut root = [0u8; 32];
+    for (i, byte) in root.iter_mut().enumerate() {
+      *byte = u8::try_from(31 - i).expect("32-byte reverse index");
+    }
+    let preimages = [AggrPreimage { digest, bytes: &[11, 12] }];
+    let trees = [AggrTree { root, bytes: &[13, 14, 15] }];
+    let paths = [AggrPath { candidate: root, bytes: &[1, 0] }];
+    let advice = AggrAdvice {
+      shape: 3,
+      proof_advice: [&[1, 2], &[3]],
+      ixvm_vk: &[4, 5],
+      self_vk: &[16, 17, 18],
+      child_claims: [&[6], &[7, 8]],
+      output_claim: &[9],
+      allowed: &[10],
+      preimages: &preimages,
+      trees: &trees,
+      paths: &paths,
+    };
+
+    let io = aggr_io_buffer(&advice);
+
+    assert_eq!(arena_bytes(&io, 0), vec![1, 2, 3]);
+    assert_eq!(info(&io, 0, index_key(0)), (0, 2));
+    assert_eq!(info(&io, 0, index_key(1)), (2, 1));
+
+    assert_eq!(arena_bytes(&io, 1), vec![4, 5, 16, 17, 18]);
+    assert_eq!(info(&io, 1, index_key(0)), (0, 2));
+    assert_eq!(info(&io, 1, index_key(1)), (2, 3));
+
+    assert_eq!(arena_bytes(&io, 2), vec![6, 7, 8, 9]);
+    assert_eq!(info(&io, 2, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 2, index_key(1)), (1, 2));
+    assert_eq!(info(&io, 2, index_key(2)), (3, 1));
+
+    assert_eq!(info(&io, 3, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 4, packed_digest_key(&digest)), (0, 2));
+    assert_eq!(info(&io, 5, address_key(&root)), (0, 3));
+    assert_eq!(arena_bytes(&io, 6), vec![3, 1, 0]);
+    assert_eq!(info(&io, 6, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 6, address_key(&root)), (1, 2));
+    assert_ne!(packed_digest_key(&digest), address_key(&digest));
+  }
+
+  #[test]
+  fn keyed_aggr_blobs_decode_strictly_without_copying_payloads() {
+    let key = [7u8; 32];
+    let mut blob = Vec::new();
+    blob.extend_from_slice(&1u32.to_le_bytes());
+    blob.extend_from_slice(&key);
+    blob.extend_from_slice(&3u32.to_le_bytes());
+    blob.extend_from_slice(&[8, 9, 10]);
+
+    let preimages = decode_aggr_preimages(&blob).expect("valid preimage blob");
+    assert_eq!(preimages.len(), 1);
+    assert_eq!(preimages[0].digest, key);
+    assert_eq!(preimages[0].bytes, &[8, 9, 10]);
+
+    let trees = decode_aggr_trees(&blob).expect("valid tree blob");
+    assert_eq!(trees[0].root, key);
+    assert_eq!(trees[0].bytes, &[8, 9, 10]);
+
+    let paths = decode_aggr_paths(&blob).expect("valid path blob");
+    assert_eq!(paths[0].candidate, key);
+    assert_eq!(paths[0].bytes, &[8, 9, 10]);
+
+    blob.push(11);
+    assert!(decode_aggr_preimages(&blob).is_err());
+    assert!(decode_aggr_trees(&[1, 0, 0]).is_err());
+    assert!(decode_aggr_paths(&[1, 0, 0]).is_err());
+  }
+}
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index e0b23dee8..814a561d3 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -26,9 +26,30 @@ fn aiur_fn_0(
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __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 };
+    let __ret: [G; OUT_0] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_1: usize = 2;
+const IN_1: usize = 2;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -61,7 +82,7 @@ fn aiur_fn_0(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -266,65 +287,66 @@ fn aiur_fn_0(
                     match __v_226.as_canonical_u64() {
                       0u64 => {
                         let __v_227: G = G::from_u64(1);
-                        let __ret: [G; OUT_0] = [__v_227];
-                        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_227: G = G::from_u64(0);
-                        let __ret: [G; OUT_0] = [__v_227];
-                        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_214: G = G::from_u64(0);
-                    let __ret: [G; OUT_0] = [__v_214];
-                    if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_1] = [__v_214];
+                    if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_177: G = G::from_u64(0);
-                let __ret: [G; OUT_0] = [__v_177];
-                if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_1] = [__v_177];
+                if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_140: G = G::from_u64(0);
-            let __ret: [G; OUT_0] = [__v_140];
-            if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_1] = [__v_140];
+            if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_103: G = G::from_u64(0);
-        let __ret: [G; OUT_0] = [__v_103];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_1] = [__v_103];
+        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_1: usize = 2;
-const IN_1: usize = 2;
-const OUT_1: usize = 1;
-fn aiur_fn_1(
-  inp: [G; IN_1],
+const INPUT_SIZE_2: usize = 2;
+const IN_2: usize = 2;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_1], ExecError> {
+) -> Result<[G; OUT_2], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -357,7 +379,7 @@ fn aiur_fn_1(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -393,32 +415,33 @@ fn aiur_fn_1(
     let __v_66: G = (__v_2 - __v_34);
     match __v_66.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } };
         let __v_67: G = __r_arr[0];
-        let __ret: [G; OUT_1] = [__v_67];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_67: G = G::from_u64(0);
-        let __ret: [G; OUT_1] = [__v_67];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_2: usize = 3;
-const IN_2: usize = 3;
-const OUT_2: usize = 1;
-fn aiur_fn_2(
-  inp: [G; IN_2],
+const INPUT_SIZE_3: usize = 3;
+const IN_3: usize = 3;
+const OUT_3: usize = 1;
+fn aiur_fn_3(
+  inp: [G; IN_3],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_3], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -426,9 +449,9 @@ fn aiur_fn_2(
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_5];
-        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -436,30 +459,31 @@ fn aiur_fn_2(
         let __v_4: G = (__v_1 + __v_3);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 - __v_5);
-        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_2] = [__v_10];
-        if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_3: usize = 8;
-const IN_3: usize = 8;
-const OUT_3: usize = 1;
-fn aiur_fn_3(
-  inp: [G; IN_3],
+const INPUT_SIZE_4: usize = 8;
+const IN_4: usize = 8;
+const OUT_4: usize = 1;
+fn aiur_fn_4(
+  inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_3], ExecError> {
+) -> Result<[G; OUT_4], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -483,14 +507,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(1);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -499,14 +523,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -519,14 +543,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -535,14 +559,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -559,14 +583,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -575,14 +599,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -595,14 +619,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -611,14 +635,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -639,14 +663,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -655,14 +679,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -675,14 +699,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -691,14 +715,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -715,14 +739,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -731,14 +755,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -751,14 +775,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -767,14 +791,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -799,14 +823,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -815,14 +839,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -835,14 +859,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -851,14 +875,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -875,14 +899,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -891,14 +915,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -911,14 +935,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -927,14 +951,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -955,14 +979,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -971,14 +995,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -991,14 +1015,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1007,14 +1031,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1031,14 +1055,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1047,14 +1071,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1067,14 +1091,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1083,14 +1107,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1119,14 +1143,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(2);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1135,14 +1159,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1155,14 +1179,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1171,14 +1195,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1195,14 +1219,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1211,14 +1235,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1231,14 +1255,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1247,14 +1271,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1275,14 +1299,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1291,14 +1315,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1311,14 +1335,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1327,14 +1351,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1351,14 +1375,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1367,14 +1391,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1387,14 +1411,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1403,14 +1427,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1435,14 +1459,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(3);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1451,14 +1475,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1471,14 +1495,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1487,14 +1511,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1511,14 +1535,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1527,14 +1551,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1547,14 +1571,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1563,14 +1587,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1591,14 +1615,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(4);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1607,14 +1631,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1627,14 +1651,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1643,14 +1667,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1667,14 +1691,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(5);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1683,14 +1707,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1703,14 +1727,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(6);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1719,14 +1743,14 @@ fn aiur_fn_3(
                             match __v_7.as_canonical_u64() {
                               0u64 => {
                                 let __v_8: G = G::from_u64(7);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(8);
-                                let __ret: [G; OUT_3] = [__v_8];
-                                if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -1745,16 +1769,17 @@ fn aiur_fn_3(
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 1;
-fn aiur_fn_4(
-  inp: [G; IN_4],
+const INPUT_SIZE_5: usize = 8;
+const IN_5: usize = 8;
+const OUT_5: usize = 1;
+fn aiur_fn_5(
+  inp: [G; IN_5],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_4], ExecError> {
+) -> Result<[G; OUT_5], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -1780,86 +1805,87 @@ fn aiur_fn_4(
                                 match __v_7.as_canonical_u64() {
                                   0u64 => {
                                     let __v_8: G = G::from_u64(1);
-                                    let __ret: [G; OUT_4] = [__v_8];
-                                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_5] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_8: G = G::from_u64(0);
-                                    let __ret: [G; OUT_4] = [__v_8];
-                                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_5] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(0);
-                                let __ret: [G; OUT_4] = [__v_8];
-                                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_5] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_8: G = G::from_u64(0);
-                            let __ret: [G; OUT_4] = [__v_8];
-                            if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_5] = [__v_8];
+                            if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_8: G = G::from_u64(0);
-                        let __ret: [G; OUT_4] = [__v_8];
-                        if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_5] = [__v_8];
+                        if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_8: G = G::from_u64(0);
-                    let __ret: [G; OUT_4] = [__v_8];
-                    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_5] = [__v_8];
+                    if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_4] = [__v_8];
-                if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_5] = [__v_8];
+                if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_4] = [__v_8];
-            if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_5] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_4] = [__v_8];
-        if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_5] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_5: usize = 8;
-const IN_5: usize = 8;
-const OUT_5: usize = 4;
-fn aiur_fn_5(
-  inp: [G; IN_5],
+const INPUT_SIZE_6: usize = 8;
+const IN_6: usize = 8;
+const OUT_6: usize = 4;
+fn aiur_fn_6(
+  inp: [G; IN_6],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_5], ExecError> {
+) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -1881,22 +1907,23 @@ fn aiur_fn_5(
     if (__v_13 != __v_12) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[6].weight(); } record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_6: usize = 12;
-const IN_6: usize = 12;
-const OUT_6: usize = 4;
-fn aiur_fn_6(
-  inp: [G; IN_6],
+const INPUT_SIZE_7: usize = 12;
+const IN_7: usize = 12;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_6], ExecError> {
+) -> Result<[G; OUT_7], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -1928,22 +1955,23 @@ fn aiur_fn_6(
     if (__v_22 != __v_23) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
     }
-    let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15];
-    if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_7] = [__v_12, __v_13, __v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[7].weight(); } record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_7: usize = 8;
-const IN_7: usize = 8;
-const OUT_7: usize = 4;
-fn aiur_fn_7(
-  inp: [G; IN_7],
+const INPUT_SIZE_8: usize = 8;
+const IN_8: usize = 8;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_7], ExecError> {
+) -> Result<[G; OUT_8], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -1956,62 +1984,65 @@ fn aiur_fn_7(
     let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
     let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
     let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[8].weight(); } record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 4;
-const IN_8: usize = 4;
-const OUT_8: usize = 4;
-fn aiur_fn_8(
-  inp: [G; IN_8],
+const INPUT_SIZE_9: usize = 4;
+const IN_9: usize = 4;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_8], ExecError> {
+) -> Result<[G; OUT_9], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1];
-    if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_9] = [__v_2, __v_3, __v_0, __v_1];
+    if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_9: usize = 4;
-const IN_9: usize = 4;
-const OUT_9: usize = 4;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+const INPUT_SIZE_10: usize = 4;
+const IN_10: usize = 4;
+const OUT_10: usize = 4;
+fn aiur_fn_10(
+  inp: [G; IN_10],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_9], ExecError> {
+) -> Result<[G; OUT_10], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0];
-    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_10] = [__v_1, __v_2, __v_3, __v_0];
+    if !unconstrained { record.virt += record.function_queries[10].weight(); } record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_10: usize = 8;
-const IN_10: usize = 8;
-const OUT_10: usize = 4;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 4;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], ExecError> {
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2036,22 +2067,23 @@ fn aiur_fn_10(
     let __v_17: G = (__v_10 + __v_13);
     let __v_18: G = (__v_12 + __v_15);
     let __v_19: G = (__v_14 + __v_9);
-    let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[11].weight(); } record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
-const OUT_11: usize = 4;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 4;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], ExecError> {
+) -> Result<[G; OUT_12], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2076,22 +2108,23 @@ fn aiur_fn_11(
     let __v_17: G = (__v_12 + __v_15);
     let __v_18: G = (__v_14 + __v_9);
     let __v_19: G = (__v_8 + __v_11);
-    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 16;
-const IN_12: usize = 16;
-const OUT_12: usize = 1;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_13: usize = 16;
+const IN_13: usize = 16;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2133,86 +2166,87 @@ fn aiur_fn_12(
                                 match __v_23.as_canonical_u64() {
                                   0u64 => {
                                     let __v_24: G = G::from_u64(1);
-                                    let __ret: [G; OUT_12] = [__v_24];
-                                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_13] = [__v_24];
+                                    if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_24: G = G::from_u64(0);
-                                    let __ret: [G; OUT_12] = [__v_24];
-                                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_13] = [__v_24];
+                                    if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_24: G = G::from_u64(0);
-                                let __ret: [G; OUT_12] = [__v_24];
-                                if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_13] = [__v_24];
+                                if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_24: G = G::from_u64(0);
-                            let __ret: [G; OUT_12] = [__v_24];
-                            if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_13] = [__v_24];
+                            if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_24: G = G::from_u64(0);
-                        let __ret: [G; OUT_12] = [__v_24];
-                        if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_13] = [__v_24];
+                        if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_24: G = G::from_u64(0);
-                    let __ret: [G; OUT_12] = [__v_24];
-                    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_13] = [__v_24];
+                    if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_24: G = G::from_u64(0);
-                let __ret: [G; OUT_12] = [__v_24];
-                if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_13] = [__v_24];
+                if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(0);
-            let __ret: [G; OUT_12] = [__v_24];
-            if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_13] = [__v_24];
+            if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_24: G = G::from_u64(0);
-        let __ret: [G; OUT_12] = [__v_24];
-        if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_13] = [__v_24];
+        if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_13: usize = 16;
-const IN_13: usize = 16;
-const OUT_13: usize = 9;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_14: usize = 16;
+const IN_14: usize = 16;
+const OUT_14: usize = 9;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2281,22 +2315,23 @@ fn aiur_fn_13(
     let __v_50: G = __b2_add.0;
     let __v_51: G = __b2_add.1;
     let __v_52: G = (__v_49 + __v_51);
-    let __ret: [G; OUT_13] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_14] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_14: usize = 8;
-const IN_14: usize = 8;
-const OUT_14: usize = 8;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_15: usize = 8;
+const IN_15: usize = 8;
+const OUT_15: usize = 8;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2329,8 +2364,8 @@ fn aiur_fn_14(
                                     let __v_13: G = G::from_u64(0);
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(0);
-                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2343,8 +2378,8 @@ fn aiur_fn_14(
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(1);
                                     let __v_16: G = (__v_7 + __v_15);
-                                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -2358,8 +2393,8 @@ fn aiur_fn_14(
                                 let __v_13: G = G::from_u64(0);
                                 let __v_14: G = G::from_u64(1);
                                 let __v_15: G = (__v_6 + __v_14);
-                                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -2372,8 +2407,8 @@ fn aiur_fn_14(
                             let __v_12: G = G::from_u64(0);
                             let __v_13: G = G::from_u64(1);
                             let __v_14: G = (__v_5 + __v_13);
-                            let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -2385,8 +2420,8 @@ fn aiur_fn_14(
                         let __v_11: G = G::from_u64(0);
                         let __v_12: G = G::from_u64(1);
                         let __v_13: G = (__v_4 + __v_12);
-                        let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -2397,8 +2432,8 @@ fn aiur_fn_14(
                     let __v_10: G = G::from_u64(0);
                     let __v_11: G = G::from_u64(1);
                     let __v_12: G = (__v_3 + __v_11);
-                    let __ret: [G; OUT_14] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -2408,8 +2443,8 @@ fn aiur_fn_14(
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = (__v_2 + __v_10);
-                let __ret: [G; OUT_14] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -2418,8 +2453,8 @@ fn aiur_fn_14(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 + __v_9);
-            let __ret: [G; OUT_14] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -2427,24 +2462,25 @@ fn aiur_fn_14(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_14] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_15: usize = 8;
-const IN_15: usize = 8;
-const OUT_15: usize = 8;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_16: usize = 8;
+const IN_16: usize = 8;
+const OUT_16: usize = 8;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2477,8 +2513,8 @@ fn aiur_fn_15(
                                     let __v_13: G = G::from_u64(0);
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(0);
-                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -2491,8 +2527,8 @@ fn aiur_fn_15(
                                     let __v_14: G = G::from_u64(255);
                                     let __v_15: G = G::from_u64(1);
                                     let __v_16: G = (__v_7 - __v_15);
-                                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -2506,8 +2542,8 @@ fn aiur_fn_15(
                                 let __v_13: G = G::from_u64(255);
                                 let __v_14: G = G::from_u64(1);
                                 let __v_15: G = (__v_6 - __v_14);
-                                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -2520,8 +2556,8 @@ fn aiur_fn_15(
                             let __v_12: G = G::from_u64(255);
                             let __v_13: G = G::from_u64(1);
                             let __v_14: G = (__v_5 - __v_13);
-                            let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -2533,8 +2569,8 @@ fn aiur_fn_15(
                         let __v_11: G = G::from_u64(255);
                         let __v_12: G = G::from_u64(1);
                         let __v_13: G = (__v_4 - __v_12);
-                        let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -2545,8 +2581,8 @@ fn aiur_fn_15(
                     let __v_10: G = G::from_u64(255);
                     let __v_11: G = G::from_u64(1);
                     let __v_12: G = (__v_3 - __v_11);
-                    let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -2556,8 +2592,8 @@ fn aiur_fn_15(
                 let __v_9: G = G::from_u64(255);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = (__v_2 - __v_10);
-                let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_16] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -2566,8 +2602,8 @@ fn aiur_fn_15(
             let __v_8: G = G::from_u64(255);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 - __v_9);
-            let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -2575,24 +2611,25 @@ fn aiur_fn_15(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 - __v_8);
-        let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_16: usize = 8;
-const IN_16: usize = 8;
-const OUT_16: usize = 1;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_17: usize = 8;
+const IN_17: usize = 8;
+const OUT_17: usize = 1;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], ExecError> {
+) -> Result<[G; OUT_17], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2623,22 +2660,23 @@ fn aiur_fn_16(
     let __v_24: G = (__v_12 + __v_23);
     let __v_25: G = (__v_10 + __v_24);
     let __v_26: G = (__v_0 + __v_25);
-    let __ret: [G; OUT_16] = [__v_26];
-    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_17] = [__v_26];
+    if !unconstrained { record.virt += record.function_queries[17].weight(); } record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 4;
-const IN_17: usize = 4;
-const OUT_17: usize = 1;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_18: usize = 4;
+const IN_18: usize = 4;
+const OUT_18: usize = 1;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2652,22 +2690,23 @@ fn aiur_fn_17(
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = (__v_5 + __v_10);
     let __v_12: G = (__v_0 + __v_11);
-    let __ret: [G; OUT_17] = [__v_12];
-    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_18] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[18].weight(); } record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 32;
-const IN_18: usize = 32;
-const OUT_18: usize = 8;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_19: usize = 32;
+const IN_19: usize = 32;
+const OUT_19: usize = 8;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], ExecError> {
+) -> Result<[G; OUT_19], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2772,22 +2811,23 @@ fn aiur_fn_18(
     let __v_101: G = (__v_98 + __v_100);
     let __v_102: G = (__v_96 + __v_101);
     let __v_103: G = (__v_28 + __v_102);
-    let __ret: [G; OUT_18] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
-    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_19] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    if !unconstrained { record.virt += record.function_queries[19].weight(); } record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 1;
-const IN_19: usize = 1;
-const OUT_19: usize = 32;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_20: usize = 1;
+const IN_20: usize = 1;
+const OUT_20: usize = 32;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
+) -> Result<[G; OUT_20], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
     let __v_2: G = G::from_u64(230);
@@ -2823,7 +2863,7 @@ fn aiur_fn_19(
     let __v_32: G = G::from_u64(91);
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -2834,14 +2874,14 @@ fn aiur_fn_19(
     let __v_43: G = G::from_u64(0);
     let __v_44: G = G::from_u64(0);
     let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_48: G = G::from_u64(1);
     let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__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];
@@ -2874,22 +2914,23 @@ fn aiur_fn_19(
     let __v_81: G = __r_arr[29];
     let __v_82: G = __r_arr[30];
     let __v_83: G = __r_arr[31];
-    let __ret: [G; OUT_19] = [__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];
-    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_20] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83];
+    if !unconstrained { record.virt += record.function_queries[20].weight(); } record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 33;
-const IN_20: usize = 33;
-const OUT_20: usize = 0;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_21: usize = 33;
+const IN_21: usize = 33;
+const OUT_21: usize = 0;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2957,7 +2998,7 @@ fn aiur_fn_20(
     let __v_64: G = G::from_u64(91);
     let __v_65: G = G::from_u64(1);
     let __v_66: G = G::from_u64(1);
-    let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_68: G = G::from_u64(0);
     let __v_69: G = G::from_u64(0);
     let __v_70: G = G::from_u64(0);
@@ -2968,14 +3009,14 @@ fn aiur_fn_20(
     let __v_75: G = G::from_u64(0);
     let __v_76: G = G::from_u64(0);
     let __v_77: G = G::from_u64(0);
-    let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_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 __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_80: G = G::from_u64(1);
     let __v_81: G = G::from_u64(1);
-    let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_83: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_83]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__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];
@@ -3104,22 +3145,23 @@ fn aiur_fn_20(
     if (__v_115 != __v_32) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) });
     }
-    let __ret: [G; OUT_20] = [];
-    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_21] = [];
+    if !unconstrained { record.virt += record.function_queries[21].weight(); } record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_21: usize = 1;
-const IN_21: usize = 1;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_22: usize = 1;
+const IN_22: usize = 1;
+const OUT_22: usize = 1;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
     let __v_2: G = G::from_u64(230);
@@ -3155,7 +3197,7 @@ fn aiur_fn_21(
     let __v_32: G = G::from_u64(91);
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -3166,14 +3208,14 @@ fn aiur_fn_21(
     let __v_43: G = G::from_u64(0);
     let __v_44: G = G::from_u64(0);
     let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_48: G = G::from_u64(1);
     let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__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];
@@ -3206,23 +3248,24 @@ fn aiur_fn_21(
     let __v_81: G = __r_arr[29];
     let __v_82: G = __r_arr[30];
     let __v_83: G = __r_arr[31];
-    let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_21] = [__v_84];
-    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_22] = [__v_84];
+    if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_22: usize = 34;
-const IN_22: usize = 34;
-const OUT_22: usize = 34;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_23: usize = 34;
+const IN_23: usize = 34;
+const OUT_23: usize = 34;
+fn aiur_fn_23(
+  inp: [G; IN_23],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -3257,7 +3300,7 @@ fn aiur_fn_22(
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
     let __v_33: G = inp[33];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -3295,13 +3338,13 @@ fn aiur_fn_22(
     match __v_34.as_canonical_u64() {
       1u64 => {
         let __v_68: G = G::from_u64(1);
-        let __ret: [G; OUT_22] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_23] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
+        if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_68: G = G::from_u64(0);
-        let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_35, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_35, __v_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]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } };
         let __v_69: G = __r_arr[0];
         let __v_70: G = __r_arr[1];
         let __v_71: G = __r_arr[2];
@@ -3339,8 +3382,8 @@ fn aiur_fn_22(
         match __v_69.as_canonical_u64() {
           0u64 => {
             let __v_103: G = G::from_u64(1);
-            let __ret: [G; OUT_22] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
-            if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_23] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
+            if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
@@ -3378,7 +3421,7 @@ fn aiur_fn_22(
             let __v_134: G = G::from_u64(205);
             let __v_135: G = G::from_u64(224);
             let __v_136: G = G::from_u64(91);
-            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
             let __v_137: G = __loaded[0];
             let __v_138: G = __loaded[1];
             let __v_139: G = __loaded[2];
@@ -3449,7 +3492,7 @@ fn aiur_fn_22(
                 let __v_202: G = G::from_u64(0);
                 let __v_203: G = G::from_u64(0);
                 let __v_204: G = G::from_u64(0);
-                let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__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];
@@ -3485,9 +3528,9 @@ fn aiur_fn_22(
                 let __v_237: G = G::from_u64(0);
                 let __v_238: G = G::from_u64(0);
                 let __v_239: G = G::from_u64(0);
-                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_22] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
-                if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_23] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
+                if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -3523,7 +3566,7 @@ fn aiur_fn_22(
                 let __v_200: G = G::from_u64(0);
                 let __v_201: G = G::from_u64(0);
                 let __v_202: G = G::from_u64(0);
-                let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
                 let __v_203: G = __r_arr[0];
                 let __v_204: G = __r_arr[1];
                 let __v_205: G = __r_arr[2];
@@ -3559,9 +3602,9 @@ fn aiur_fn_22(
                 let __v_235: G = G::from_u64(0);
                 let __v_236: G = G::from_u64(0);
                 let __v_237: G = G::from_u64(0);
-                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_22] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
-                if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_23] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
+                if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -3578,18 +3621,19 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 32;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_24: usize = 1;
+const IN_24: usize = 1;
+const OUT_24: usize = 32;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_24], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -3626,7 +3670,7 @@ fn aiur_fn_23(
     let __v_34: G = __loaded[33];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
         let __v_35: G = __loaded[0];
         let __v_36: G = __loaded[1];
         let __v_37: G = __loaded[2];
@@ -3663,13 +3707,13 @@ fn aiur_fn_23(
         let __v_68: G = __loaded[33];
         match __v_35.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_23] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
-            if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_24] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
+            if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_69: G = G::from_u64(1);
-            let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[23].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } };
             let __v_70: G = __r_arr[0];
             let __v_71: G = __r_arr[1];
             let __v_72: G = __r_arr[2];
@@ -3706,7 +3750,7 @@ fn aiur_fn_23(
             let __v_103: G = __r_arr[33];
             match __v_70.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } };
                 let __v_104: G = __r_arr[0];
                 let __v_105: G = __r_arr[1];
                 let __v_106: G = __r_arr[2];
@@ -3739,14 +3783,14 @@ fn aiur_fn_23(
                 let __v_133: G = __r_arr[29];
                 let __v_134: G = __r_arr[30];
                 let __v_135: G = __r_arr[31];
-                let __ret: [G; OUT_23] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
-                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_24] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
+                if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_104: G = G::from_u64(0);
-                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } };
                 let __v_106: G = __r_arr[0];
                 let __v_107: G = __r_arr[1];
                 let __v_108: G = __r_arr[2];
@@ -3779,8 +3823,8 @@ fn aiur_fn_23(
                 let __v_135: G = __r_arr[29];
                 let __v_136: G = __r_arr[30];
                 let __v_137: G = __r_arr[31];
-                let __ret: [G; OUT_23] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
-                if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_24] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
+                if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -3797,16 +3841,17 @@ fn aiur_fn_23(
   })
 }
 
-const INPUT_SIZE_24: usize = 7;
-const IN_24: usize = 7;
-const OUT_24: usize = 1;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_25: usize = 7;
+const IN_25: usize = 7;
+const OUT_25: usize = 1;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -3814,27 +3859,27 @@ fn aiur_fn_24(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[28].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[28].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_24] = [__v_10];
-        if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_25] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         match __v_2.as_canonical_u64() {
           63u64 => {
-            let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_28(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_28] = unsafe { *(result.output.as_ptr() as *const [G; OUT_28]) }; __ret } } else { aiur_fn_28(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[29].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[29].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_24] = [__v_12];
-            if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_25] = [__v_12];
+            if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -3842,10 +3887,10 @@ fn aiur_fn_24(
             let __v_13: G = (__v_2 + __v_12);
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_24] = [__v_16];
-            if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_25] = [__v_16];
+            if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -3857,403 +3902,404 @@ fn aiur_fn_24(
   })
 }
 
-const INPUT_SIZE_25: usize = 1;
-const IN_25: usize = 1;
-const OUT_25: usize = 64;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 64;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_26], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 let __v_12: G = __loaded[2];
                 match __v_10.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                     let __v_13: G = __loaded[0];
                     let __v_14: G = __loaded[1];
                     let __v_15: G = __loaded[2];
                     match __v_13.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                         let __v_16: G = __loaded[0];
                         let __v_17: G = __loaded[1];
                         let __v_18: G = __loaded[2];
                         match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                             let __v_19: G = __loaded[0];
                             let __v_20: G = __loaded[1];
                             let __v_21: G = __loaded[2];
                             match __v_19.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                 let __v_22: G = __loaded[0];
                                 let __v_23: G = __loaded[1];
                                 let __v_24: G = __loaded[2];
                                 match __v_22.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                                     let __v_26: G = __loaded[1];
                                     let __v_27: G = __loaded[2];
                                     match __v_25.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                         let __v_28: G = __loaded[0];
                                         let __v_29: G = __loaded[1];
                                         let __v_30: G = __loaded[2];
                                         match __v_28.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                             let __v_31: G = __loaded[0];
                                             let __v_32: G = __loaded[1];
                                             let __v_33: G = __loaded[2];
                                             match __v_31.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                 let __v_34: G = __loaded[0];
                                                 let __v_35: G = __loaded[1];
                                                 let __v_36: G = __loaded[2];
                                                 match __v_34.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                     let __v_37: G = __loaded[0];
                                                     let __v_38: G = __loaded[1];
                                                     let __v_39: G = __loaded[2];
                                                     match __v_37.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                         let __v_40: G = __loaded[0];
                                                         let __v_41: G = __loaded[1];
                                                         let __v_42: G = __loaded[2];
                                                         match __v_40.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                             let __v_43: G = __loaded[0];
                                                             let __v_44: G = __loaded[1];
                                                             let __v_45: G = __loaded[2];
                                                             match __v_43.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                 let __v_46: G = __loaded[0];
                                                                 let __v_47: G = __loaded[1];
                                                                 let __v_48: G = __loaded[2];
                                                                 match __v_46.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                     let __v_49: G = __loaded[0];
                                                                     let __v_50: G = __loaded[1];
                                                                     let __v_51: G = __loaded[2];
                                                                     match __v_49.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                         let __v_52: G = __loaded[0];
                                                                         let __v_53: G = __loaded[1];
                                                                         let __v_54: G = __loaded[2];
                                                                         match __v_52.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                             let __v_55: G = __loaded[0];
                                                                             let __v_56: G = __loaded[1];
                                                                             let __v_57: G = __loaded[2];
                                                                             match __v_55.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                 let __v_58: G = __loaded[0];
                                                                                 let __v_59: G = __loaded[1];
                                                                                 let __v_60: G = __loaded[2];
                                                                                 match __v_58.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                     let __v_61: G = __loaded[0];
                                                                                     let __v_62: G = __loaded[1];
                                                                                     let __v_63: G = __loaded[2];
                                                                                     match __v_61.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                         let __v_64: G = __loaded[0];
                                                                                         let __v_65: G = __loaded[1];
                                                                                         let __v_66: G = __loaded[2];
                                                                                         match __v_64.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                             let __v_67: G = __loaded[0];
                                                                                             let __v_68: G = __loaded[1];
                                                                                             let __v_69: G = __loaded[2];
                                                                                             match __v_67.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                 let __v_70: G = __loaded[0];
                                                                                                 let __v_71: G = __loaded[1];
                                                                                                 let __v_72: G = __loaded[2];
                                                                                                 match __v_70.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                     let __v_73: G = __loaded[0];
                                                                                                     let __v_74: G = __loaded[1];
                                                                                                     let __v_75: G = __loaded[2];
                                                                                                     match __v_73.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                         let __v_76: G = __loaded[0];
                                                                                                         let __v_77: G = __loaded[1];
                                                                                                         let __v_78: G = __loaded[2];
                                                                                                         match __v_76.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                             let __v_79: G = __loaded[0];
                                                                                                             let __v_80: G = __loaded[1];
                                                                                                             let __v_81: G = __loaded[2];
                                                                                                             match __v_79.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                 let __v_82: G = __loaded[0];
                                                                                                                 let __v_83: G = __loaded[1];
                                                                                                                 let __v_84: G = __loaded[2];
                                                                                                                 match __v_82.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                     let __v_85: G = __loaded[0];
                                                                                                                     let __v_86: G = __loaded[1];
                                                                                                                     let __v_87: G = __loaded[2];
                                                                                                                     match __v_85.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                         let __v_88: G = __loaded[0];
                                                                                                                         let __v_89: G = __loaded[1];
                                                                                                                         let __v_90: G = __loaded[2];
                                                                                                                         match __v_88.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                             let __v_91: G = __loaded[0];
                                                                                                                             let __v_92: G = __loaded[1];
                                                                                                                             let __v_93: G = __loaded[2];
                                                                                                                             match __v_91.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                 let __v_94: G = __loaded[0];
                                                                                                                                 let __v_95: G = __loaded[1];
                                                                                                                                 let __v_96: G = __loaded[2];
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
-                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                     let __v_97: G = __loaded[0];
                                                                                                                                     let __v_98: G = __loaded[1];
                                                                                                                                     let __v_99: G = __loaded[2];
                                                                                                                                     match __v_97.as_canonical_u64() {
                                                                                                                                       0u64 => {
-                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                         let __v_100: G = __loaded[0];
                                                                                                                                         let __v_101: G = __loaded[1];
                                                                                                                                         let __v_102: G = __loaded[2];
                                                                                                                                         match __v_100.as_canonical_u64() {
                                                                                                                                           0u64 => {
-                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                             let __v_103: G = __loaded[0];
                                                                                                                                             let __v_104: G = __loaded[1];
                                                                                                                                             let __v_105: G = __loaded[2];
                                                                                                                                             match __v_103.as_canonical_u64() {
                                                                                                                                               0u64 => {
-                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                 let __v_106: G = __loaded[0];
                                                                                                                                                 let __v_107: G = __loaded[1];
                                                                                                                                                 let __v_108: G = __loaded[2];
                                                                                                                                                 match __v_106.as_canonical_u64() {
                                                                                                                                                   0u64 => {
-                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                     let __v_109: G = __loaded[0];
                                                                                                                                                     let __v_110: G = __loaded[1];
                                                                                                                                                     let __v_111: G = __loaded[2];
                                                                                                                                                     match __v_109.as_canonical_u64() {
                                                                                                                                                       0u64 => {
-                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                         let __v_112: G = __loaded[0];
                                                                                                                                                         let __v_113: G = __loaded[1];
                                                                                                                                                         let __v_114: G = __loaded[2];
                                                                                                                                                         match __v_112.as_canonical_u64() {
                                                                                                                                                           0u64 => {
-                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                             let __v_115: G = __loaded[0];
                                                                                                                                                             let __v_116: G = __loaded[1];
                                                                                                                                                             let __v_117: G = __loaded[2];
                                                                                                                                                             match __v_115.as_canonical_u64() {
                                                                                                                                                               0u64 => {
-                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                 let __v_118: G = __loaded[0];
                                                                                                                                                                 let __v_119: G = __loaded[1];
                                                                                                                                                                 let __v_120: G = __loaded[2];
                                                                                                                                                                 match __v_118.as_canonical_u64() {
                                                                                                                                                                   0u64 => {
-                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                     let __v_121: G = __loaded[0];
                                                                                                                                                                     let __v_122: G = __loaded[1];
                                                                                                                                                                     let __v_123: G = __loaded[2];
                                                                                                                                                                     match __v_121.as_canonical_u64() {
                                                                                                                                                                       0u64 => {
-                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                         let __v_124: G = __loaded[0];
                                                                                                                                                                         let __v_125: G = __loaded[1];
                                                                                                                                                                         let __v_126: G = __loaded[2];
                                                                                                                                                                         match __v_124.as_canonical_u64() {
                                                                                                                                                                           0u64 => {
-                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                             let __v_127: G = __loaded[0];
                                                                                                                                                                             let __v_128: G = __loaded[1];
                                                                                                                                                                             let __v_129: G = __loaded[2];
                                                                                                                                                                             match __v_127.as_canonical_u64() {
                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                 let __v_130: G = __loaded[0];
                                                                                                                                                                                 let __v_131: G = __loaded[1];
                                                                                                                                                                                 let __v_132: G = __loaded[2];
                                                                                                                                                                                 match __v_130.as_canonical_u64() {
                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                     let __v_133: G = __loaded[0];
                                                                                                                                                                                     let __v_134: G = __loaded[1];
                                                                                                                                                                                     let __v_135: G = __loaded[2];
                                                                                                                                                                                     match __v_133.as_canonical_u64() {
                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                         let __v_136: G = __loaded[0];
                                                                                                                                                                                         let __v_137: G = __loaded[1];
                                                                                                                                                                                         let __v_138: G = __loaded[2];
                                                                                                                                                                                         match __v_136.as_canonical_u64() {
                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                             let __v_139: G = __loaded[0];
                                                                                                                                                                                             let __v_140: G = __loaded[1];
                                                                                                                                                                                             let __v_141: G = __loaded[2];
                                                                                                                                                                                             match __v_139.as_canonical_u64() {
                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                 let __v_142: G = __loaded[0];
                                                                                                                                                                                                 let __v_143: G = __loaded[1];
                                                                                                                                                                                                 let __v_144: G = __loaded[2];
                                                                                                                                                                                                 match __v_142.as_canonical_u64() {
                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                     let __v_145: G = __loaded[0];
                                                                                                                                                                                                     let __v_146: G = __loaded[1];
                                                                                                                                                                                                     let __v_147: G = __loaded[2];
                                                                                                                                                                                                     match __v_145.as_canonical_u64() {
                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                         let __v_148: G = __loaded[0];
                                                                                                                                                                                                         let __v_149: G = __loaded[1];
                                                                                                                                                                                                         let __v_150: G = __loaded[2];
                                                                                                                                                                                                         match __v_148.as_canonical_u64() {
                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                             let __v_151: G = __loaded[0];
                                                                                                                                                                                                             let __v_152: G = __loaded[1];
                                                                                                                                                                                                             let __v_153: G = __loaded[2];
                                                                                                                                                                                                             match __v_151.as_canonical_u64() {
                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                 let __v_154: G = __loaded[0];
                                                                                                                                                                                                                 let __v_155: G = __loaded[1];
                                                                                                                                                                                                                 let __v_156: G = __loaded[2];
                                                                                                                                                                                                                 match __v_154.as_canonical_u64() {
                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                     let __v_157: G = __loaded[0];
                                                                                                                                                                                                                     let __v_158: G = __loaded[1];
                                                                                                                                                                                                                     let __v_159: G = __loaded[2];
                                                                                                                                                                                                                     match __v_157.as_canonical_u64() {
                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                         let __v_160: G = __loaded[0];
                                                                                                                                                                                                                         let __v_161: G = __loaded[1];
                                                                                                                                                                                                                         let __v_162: G = __loaded[2];
                                                                                                                                                                                                                         match __v_160.as_canonical_u64() {
                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                             let __v_163: G = __loaded[0];
                                                                                                                                                                                                                             let __v_164: G = __loaded[1];
                                                                                                                                                                                                                             let __v_165: G = __loaded[2];
                                                                                                                                                                                                                             match __v_163.as_canonical_u64() {
                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                 let __v_166: G = __loaded[0];
                                                                                                                                                                                                                                 let __v_167: G = __loaded[1];
                                                                                                                                                                                                                                 let __v_168: G = __loaded[2];
                                                                                                                                                                                                                                 match __v_166.as_canonical_u64() {
                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                     let __v_169: G = __loaded[0];
                                                                                                                                                                                                                                     let __v_170: G = __loaded[1];
                                                                                                                                                                                                                                     let __v_171: G = __loaded[2];
                                                                                                                                                                                                                                     match __v_169.as_canonical_u64() {
                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                         let __v_172: G = __loaded[0];
                                                                                                                                                                                                                                         let __v_173: G = __loaded[1];
                                                                                                                                                                                                                                         let __v_174: G = __loaded[2];
                                                                                                                                                                                                                                         match __v_172.as_canonical_u64() {
                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                             let __v_175: G = __loaded[0];
                                                                                                                                                                                                                                             let __v_176: G = __loaded[1];
                                                                                                                                                                                                                                             let __v_177: G = __loaded[2];
                                                                                                                                                                                                                                             match __v_175.as_canonical_u64() {
                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                 let __v_178: G = __loaded[0];
                                                                                                                                                                                                                                                 let __v_179: G = __loaded[1];
                                                                                                                                                                                                                                                 let __v_180: G = __loaded[2];
                                                                                                                                                                                                                                                 match __v_178.as_canonical_u64() {
                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                     let __v_181: G = __loaded[0];
                                                                                                                                                                                                                                                     let __v_182: G = __loaded[1];
                                                                                                                                                                                                                                                     let __v_183: G = __loaded[2];
                                                                                                                                                                                                                                                     match __v_181.as_canonical_u64() {
                                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                         let __v_184: G = __loaded[0];
                                                                                                                                                                                                                                                         let __v_185: G = __loaded[1];
                                                                                                                                                                                                                                                         let __v_186: G = __loaded[2];
                                                                                                                                                                                                                                                         match __v_184.as_canonical_u64() {
                                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                             let __v_187: G = __loaded[0];
                                                                                                                                                                                                                                                             let __v_188: G = __loaded[1];
                                                                                                                                                                                                                                                             let __v_189: G = __loaded[2];
                                                                                                                                                                                                                                                             match __v_187.as_canonical_u64() {
                                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                                 let __v_190: G = __loaded[0];
                                                                                                                                                                                                                                                                 let __v_191: G = __loaded[1];
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_25] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
-                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_26] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4578,50 +4624,52 @@ fn aiur_fn_25(
   })
 }
 
-const INPUT_SIZE_26: usize = 2;
-const IN_26: usize = 2;
-const OUT_26: usize = 1;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_27: usize = 2;
+const IN_27: usize = 2;
+const OUT_27: usize = 1;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> Result<[G; OUT_27], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_26] = [__v_0];
-        if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_27] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(0);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_26] = [__v_7];
-        if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_27] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_27: usize = 6;
-const IN_27: usize = 6;
-const OUT_27: usize = 1;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_28: usize = 6;
+const IN_28: usize = 6;
+const OUT_28: usize = 1;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_28], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -4635,7 +4683,7 @@ fn aiur_fn_27(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
             let __v_9: G = __loaded[0];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -4662,7 +4710,7 @@ fn aiur_fn_27(
                                           0u64 => {
                                             let __v_17: G = (__v_6 + __v_7);
                                             let __v_18: G = (__v_8 + __v_17);
-                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
                                             let __v_19: G = __loaded[0];
                                             let __v_20: G = __loaded[1];
                                             let __v_21: G = __loaded[2];
@@ -4759,7 +4807,7 @@ fn aiur_fn_27(
                                             let __v_112: G = G::from_u64(0);
                                             let __v_113: G = G::from_u64(0);
                                             let __v_114: G = G::from_u64(0);
-                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
                                             let __v_115: G = __loaded[0];
                                             let __v_116: G = __loaded[1];
                                             let __v_117: G = __loaded[2];
@@ -4793,7 +4841,7 @@ fn aiur_fn_27(
                                             let __v_145: G = G::from_u64(0);
                                             let __v_146: G = G::from_u64(0);
                                             let __v_147: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
                                             let __v_148: G = __r_arr[0];
                                             let __v_149: G = __r_arr[1];
                                             let __v_150: G = __r_arr[2];
@@ -4826,70 +4874,70 @@ fn aiur_fn_27(
                                             let __v_177: G = __r_arr[29];
                                             let __v_178: G = __r_arr[30];
                                             let __v_179: G = __r_arr[31];
-                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_27] = [__v_180];
-                                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __ret: [G; OUT_28] = [__v_180];
+                                            if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_27] = [__v_5];
-                                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_28] = [__v_5];
+                                            if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_27] = [__v_5];
-                                        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_28] = [__v_5];
+                                        if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_27] = [__v_5];
-                                    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_28] = [__v_5];
+                                    if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_27] = [__v_5];
-                                if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_28] = [__v_5];
+                                if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_27] = [__v_5];
-                            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_28] = [__v_5];
+                            if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_27] = [__v_5];
-                        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_28] = [__v_5];
+                        if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_27] = [__v_5];
-                    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_28] = [__v_5];
+                    if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_27] = [__v_5];
-                if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_28] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
             let __v_10: G = __loaded[0];
             let __v_11: G = __loaded[1];
             let __v_12: G = __loaded[2];
@@ -4922,15 +4970,15 @@ fn aiur_fn_27(
             let __v_39: G = __loaded[29];
             let __v_40: G = __loaded[30];
             let __v_41: G = __loaded[31];
-            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_27] = [__v_42];
-            if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_28] = [__v_42];
+            if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -4939,7 +4987,7 @@ fn aiur_fn_27(
         let __v_14: G = __loaded[5];
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __v_18: G = (__v_17 * __v_8);
         let __v_19: G = (__v_2 - __v_1);
@@ -4949,9 +4997,9 @@ fn aiur_fn_27(
         let __v_23: G = (__v_7 + __v_22);
         let __v_24: G = G::from_u64(64);
         let __v_25: G = (__v_24 - __v_1);
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__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];
@@ -5016,7 +5064,7 @@ fn aiur_fn_27(
         let __v_88: G = __r_arr[61];
         let __v_89: G = __r_arr[62];
         let __v_90: G = __r_arr[63];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_91: G = __loaded[0];
         let __v_92: G = __loaded[1];
         let __v_93: G = __loaded[2];
@@ -5049,7 +5097,7 @@ fn aiur_fn_27(
         let __v_120: G = __loaded[29];
         let __v_121: G = __loaded[30];
         let __v_122: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_123: G = __loaded[0];
         let __v_124: G = __loaded[1];
         let __v_125: G = __loaded[2];
@@ -5082,7 +5130,7 @@ fn aiur_fn_27(
         let __v_152: G = G::from_u64(0);
         let __v_153: G = G::from_u64(0);
         let __v_154: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_155: G = __r_arr[0];
         let __v_156: G = __r_arr[1];
         let __v_157: G = __r_arr[2];
@@ -5115,25 +5163,26 @@ fn aiur_fn_27(
         let __v_184: G = __r_arr[29];
         let __v_185: G = __r_arr[30];
         let __v_186: G = __r_arr[31];
-        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_27] = [__v_187];
-        if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_28] = [__v_187];
+        if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_28: usize = 6;
-const IN_28: usize = 6;
-const OUT_28: usize = 1;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_29: usize = 6;
+const IN_29: usize = 6;
+const OUT_29: usize = 1;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> Result<[G; OUT_29], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -5143,7 +5192,7 @@ fn aiur_fn_28(
     let __v_6: G = G::from_u64(1);
     let __v_7: G = G::from_u64(2);
     let __v_8: G = G::from_u64(8);
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__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];
@@ -5210,9 +5259,9 @@ fn aiur_fn_28(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; 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 { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } 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 __v_73: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_75: G = __loaded[1];
         let __v_76: G = __loaded[2];
@@ -5221,7 +5270,7 @@ fn aiur_fn_28(
         let __v_79: G = __loaded[5];
         let __v_80: G = __loaded[6];
         let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
         let __v_83: G = (__v_73 * __v_82);
         let __v_84: G = (__v_8 * __v_83);
@@ -5258,7 +5307,7 @@ fn aiur_fn_28(
         let __v_115: G = G::from_u64(205);
         let __v_116: G = G::from_u64(224);
         let __v_117: G = G::from_u64(91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_118: G = __loaded[0];
         let __v_119: G = __loaded[1];
         let __v_120: G = __loaded[2];
@@ -5291,7 +5340,7 @@ fn aiur_fn_28(
         let __v_147: G = __loaded[29];
         let __v_148: G = __loaded[30];
         let __v_149: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_150: G = __loaded[0];
         let __v_151: G = __loaded[1];
         let __v_152: G = __loaded[2];
@@ -5325,7 +5374,7 @@ fn aiur_fn_28(
         let __v_180: G = G::from_u64(0);
         let __v_181: G = G::from_u64(0);
         let __v_182: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_183: G = __r_arr[0];
         let __v_184: G = __r_arr[1];
         let __v_185: G = __r_arr[2];
@@ -5358,13 +5407,13 @@ fn aiur_fn_28(
         let __v_212: G = __r_arr[29];
         let __v_213: G = __r_arr[30];
         let __v_214: G = __r_arr[31];
-        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_216: G = G::from_u64(1);
         let __v_217: G = G::from_u64(1);
-        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_219: G = G::from_u64(0);
         let __v_220: G = G::from_u64(0);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_221: G = __loaded[0];
         let __v_222: G = __loaded[1];
         let __v_223: G = __loaded[2];
@@ -5373,7 +5422,7 @@ fn aiur_fn_28(
         let __v_226: G = __loaded[5];
         let __v_227: G = __loaded[6];
         let __v_228: G = __loaded[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_229: G = __r_arr[0];
         let __v_230: G = __r_arr[1];
         let __v_231: G = __r_arr[2];
@@ -5382,21 +5431,21 @@ fn aiur_fn_28(
         let __v_234: G = __r_arr[5];
         let __v_235: G = __r_arr[6];
         let __v_236: G = __r_arr[7];
-        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
         let __v_239: G = __r_arr[0];
-        let __ret: [G; OUT_28] = [__v_239];
-        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_29] = [__v_239];
+        if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; 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 { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } 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 __v_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0]; 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 { let __r = record.function_queries[768].replay_at(__i); record.virt += __r; } 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 __v_75: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_77: G = __loaded[1];
         let __v_78: G = __loaded[2];
@@ -5405,7 +5454,7 @@ fn aiur_fn_28(
         let __v_81: G = __loaded[5];
         let __v_82: G = __loaded[6];
         let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_84: G = __r_arr[0];
         let __v_85: G = (__v_84 * __v_8);
         let __v_86: G = (__v_75 * __v_85);
@@ -5415,7 +5464,7 @@ fn aiur_fn_28(
         let __v_90: G = (__v_89 * __v_6);
         let __v_91: G = (__v_86 + __v_90);
         let __v_92: G = (__v_74 + __v_91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_93: G = __loaded[0];
         let __v_94: G = __loaded[1];
         let __v_95: G = __loaded[2];
@@ -5448,7 +5497,7 @@ fn aiur_fn_28(
         let __v_122: G = __loaded[29];
         let __v_123: G = __loaded[30];
         let __v_124: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_125: G = __loaded[0];
         let __v_126: G = __loaded[1];
         let __v_127: G = __loaded[2];
@@ -5481,7 +5530,7 @@ fn aiur_fn_28(
         let __v_154: G = G::from_u64(0);
         let __v_155: G = G::from_u64(0);
         let __v_156: G = G::from_u64(0);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_157: G = __r_arr[0];
         let __v_158: G = __r_arr[1];
         let __v_159: G = __r_arr[2];
@@ -5516,31 +5565,32 @@ fn aiur_fn_28(
         let __v_188: G = __r_arr[31];
         let __v_189: G = G::from_u64(1);
         let __v_190: G = G::from_u64(1);
-        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_192: G = G::from_u64(0);
         let __v_193: G = G::from_u64(1);
         let __v_194: G = (__v_2 + __v_193);
-        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
         let __v_196: G = __r_arr[0];
-        let __ret: [G; OUT_28] = [__v_196];
-        if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_29] = [__v_196];
+        if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_29: usize = 24;
-const IN_29: usize = 24;
-const OUT_29: usize = 16;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_30: usize = 24;
+const IN_30: usize = 24;
+const OUT_30: usize = 16;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -5669,22 +5719,23 @@ fn aiur_fn_29(
     let __v_89: G = (__v_82 + __v_85);
     let __v_90: G = (__v_84 + __v_87);
     let __v_91: G = (__v_86 + __v_81);
-    let __ret: [G; OUT_29] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
-    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_30] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
+    if !unconstrained { record.virt += record.function_queries[30].weight(); } record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_30: usize = 128;
-const IN_30: usize = 128;
-const OUT_30: usize = 128;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_31: usize = 128;
+const IN_31: usize = 128;
+const OUT_31: usize = 128;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -6645,22 +6696,23 @@ fn aiur_fn_30(
     let __v_669: G = (__v_662 + __v_665);
     let __v_670: G = (__v_664 + __v_667);
     let __v_671: G = (__v_666 + __v_661);
-    let __ret: [G; OUT_30] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
-    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_31] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
+    if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 106;
-const IN_31: usize = 106;
-const OUT_31: usize = 32;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_32: usize = 106;
+const IN_32: usize = 106;
+const OUT_32: usize = 32;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_31], ExecError> {
+) -> Result<[G; OUT_32], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -6790,7 +6842,7 @@ fn aiur_fn_31(
     let __v_126: G = G::from_u64(0);
     let __v_127: G = G::from_u64(0);
     let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
     let __v_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -6823,22 +6875,23 @@ fn aiur_fn_31(
     let __v_158: G = __r_arr[29];
     let __v_159: G = __r_arr[30];
     let __v_160: G = __r_arr[31];
-    let __ret: [G; OUT_31] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-    if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+    if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_32: usize = 129;
-const IN_32: usize = 129;
-const OUT_32: usize = 32;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_33: usize = 129;
+const IN_33: usize = 129;
+const OUT_33: usize = 32;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_32], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -7002,8 +7055,8 @@ fn aiur_fn_32(
         let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
         let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
         let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
-        let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_33] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+        if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -7841,7 +7894,7 @@ fn aiur_fn_32(
         let __v_672: G = (__v_667 + __v_662);
         let __v_673: G = G::from_u64(1);
         let __v_674: G = (__v_0 + __v_673);
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[33].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } };
         let __v_675: G = __r_arr[0];
         let __v_676: G = __r_arr[1];
         let __v_677: G = __r_arr[2];
@@ -7874,24 +7927,25 @@ fn aiur_fn_32(
         let __v_704: G = __r_arr[29];
         let __v_705: G = __r_arr[30];
         let __v_706: G = __r_arr[31];
-        let __ret: [G; OUT_32] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
-        if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_33] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
+        if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_33: usize = 19;
-const IN_33: usize = 19;
-const OUT_33: usize = 1;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_34: usize = 19;
+const IN_34: usize = 19;
+const OUT_34: usize = 1;
+fn aiur_fn_34(
+  inp: [G; IN_34],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], ExecError> {
+) -> Result<[G; OUT_34], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -7914,22 +7968,22 @@ fn aiur_fn_33(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_19: G = G::from_u64(1);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; 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 { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7939,18 +7993,18 @@ fn aiur_fn_33(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(2);
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_29]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_30];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_30];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_9]; 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 { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7960,18 +8014,18 @@ fn aiur_fn_33(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(3);
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_29]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_30];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_30];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -7991,34 +8045,34 @@ fn aiur_fn_33(
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
         let __v_37: G = G::from_u64(4);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_40];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_40];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_19: G = G::from_u64(5);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_19: G = G::from_u64(6);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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 { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8028,16 +8082,16 @@ fn aiur_fn_33(
         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_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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, __v_18]; 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 { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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];
-        let __ret: [G; OUT_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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 { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8047,16 +8101,16 @@ fn aiur_fn_33(
         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_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, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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];
-        let __ret: [G; OUT_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8066,16 +8120,16 @@ fn aiur_fn_33(
         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_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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];
-        let __ret: [G; OUT_33] = [__v_29];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       10u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8094,7 +8148,7 @@ fn aiur_fn_33(
         let __v_34: G = __loaded[15];
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8113,7 +8167,7 @@ fn aiur_fn_33(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8133,24 +8187,24 @@ fn aiur_fn_33(
         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_33] = { let __args: [G; IN_33] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_37] = { let __args: [G; IN_37] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_33] = [__v_77];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_77];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __ret: [G; OUT_33] = [__v_20];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_34] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8160,16 +8214,17 @@ fn aiur_fn_33(
   })
 }
 
-const INPUT_SIZE_34: usize = 10;
-const IN_34: usize = 10;
-const OUT_34: usize = 1;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_35: usize = 10;
+const IN_35: usize = 10;
+const OUT_35: usize = 1;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8182,8 +8237,8 @@ fn aiur_fn_34(
     let __v_9: G = inp[9];
     match __v_8.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_34] = [__v_9];
-        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_35] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8191,27 +8246,28 @@ fn aiur_fn_34(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_8 - __v_12);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_34] = [__v_15];
-        if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_35] = [__v_15];
+        if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_35: usize = 9;
-const IN_35: usize = 9;
-const OUT_35: usize = 1;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_36: usize = 9;
+const IN_36: usize = 9;
+const OUT_36: usize = 1;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], ExecError> {
+) -> Result<[G; OUT_36], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8221,7 +8277,7 @@ fn aiur_fn_35(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = G::from_u64(128);
     let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) };
@@ -8230,9 +8286,9 @@ fn aiur_fn_35(
         match __v_11.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_35] = [__v_13];
-            if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_36] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -8241,11 +8297,11 @@ fn aiur_fn_35(
             let __v_14: G = (__v_9 - __v_13);
             let __v_15: G = (__v_12 + __v_14);
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_35] = [__v_18];
-            if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_36] = [__v_18];
+            if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -8256,86 +8312,11 @@ fn aiur_fn_35(
         let __v_14: G = (__v_9 - __v_13);
         let __v_15: G = (__v_12 + __v_14);
         let __v_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_18];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_36: usize = 10;
-const IN_36: usize = 10;
-const OUT_36: usize = 1;
-fn aiur_fn_36(
-  inp: [G; IN_36],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __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_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = G::from_u64(32);
-    let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_13: G = G::from_u64(64);
-            let __v_14: G = (__v_0 * __v_13);
-            let __v_15: G = (__v_14 + __v_1);
-            let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_36] = [__v_17];
-            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_13: G = G::from_u64(64);
-            let __v_14: G = (__v_0 * __v_13);
-            let __v_15: G = G::from_u64(32);
-            let __v_16: G = G::from_u64(1);
-            let __v_17: G = (__v_10 - __v_16);
-            let __v_18: G = (__v_15 + __v_17);
-            let __v_19: G = (__v_14 + __v_18);
-            let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_36] = [__v_22];
-            if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      _ => {
-        let __v_13: G = G::from_u64(64);
-        let __v_14: G = (__v_0 * __v_13);
-        let __v_15: G = G::from_u64(32);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = (__v_10 - __v_16);
-        let __v_18: G = (__v_15 + __v_17);
-        let __v_19: G = (__v_14 + __v_18);
-        let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_36] = [__v_22];
-        if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_36] = [__v_18];
+        if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -8352,6 +8333,7 @@ fn aiur_fn_37(
   unconstrained: bool,
 ) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8362,63 +8344,63 @@ fn aiur_fn_37(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[3].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_3(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_3] = unsafe { *(result.output.as_ptr() as *const [G; OUT_3]) }; __ret } } else { aiur_fn_3(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __v_11: G = G::from_u64(8);
+    let __v_11: G = G::from_u64(32);
     let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
     match __v_10.as_canonical_u64() {
       1u64 => {
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __v_13: G = G::from_u64(16);
+            let __v_13: G = G::from_u64(64);
             let __v_14: G = (__v_0 * __v_13);
             let __v_15: G = (__v_14 + __v_1);
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_37] = [__v_17];
-            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __v_13: G = G::from_u64(16);
+            let __v_13: G = G::from_u64(64);
             let __v_14: G = (__v_0 * __v_13);
-            let __v_15: G = G::from_u64(8);
+            let __v_15: G = G::from_u64(32);
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_10 - __v_16);
             let __v_18: G = (__v_15 + __v_17);
             let __v_19: G = (__v_14 + __v_18);
             let __v_20: G = G::from_u64(0);
-            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_37] = [__v_22];
-            if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __v_13: G = G::from_u64(16);
+        let __v_13: G = G::from_u64(64);
         let __v_14: G = (__v_0 * __v_13);
-        let __v_15: G = G::from_u64(8);
+        let __v_15: G = G::from_u64(32);
         let __v_16: G = G::from_u64(1);
         let __v_17: G = (__v_10 - __v_16);
         let __v_18: G = (__v_15 + __v_17);
         let __v_19: G = (__v_14 + __v_18);
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_37] = [__v_22];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 2;
-const IN_38: usize = 2;
+const INPUT_SIZE_38: usize = 10;
+const IN_38: usize = 10;
 const OUT_38: usize = 1;
 fn aiur_fn_38(
   inp: [G; IN_38],
@@ -8427,9 +8409,86 @@ fn aiur_fn_38(
   unconstrained: bool,
 ) -> Result<[G; OUT_38], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = 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_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(8);
+    let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) };
+    match __v_10.as_canonical_u64() {
+      1u64 => {
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __v_13: G = G::from_u64(16);
+            let __v_14: G = (__v_0 * __v_13);
+            let __v_15: G = (__v_14 + __v_1);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_38] = [__v_17];
+            if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_13: G = G::from_u64(16);
+            let __v_14: G = (__v_0 * __v_13);
+            let __v_15: G = G::from_u64(8);
+            let __v_16: G = G::from_u64(1);
+            let __v_17: G = (__v_10 - __v_16);
+            let __v_18: G = (__v_15 + __v_17);
+            let __v_19: G = (__v_14 + __v_18);
+            let __v_20: G = G::from_u64(0);
+            let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+            let __v_21: G = __r_arr[0];
+            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_38] = [__v_22];
+            if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_13: G = G::from_u64(16);
+        let __v_14: G = (__v_0 * __v_13);
+        let __v_15: G = G::from_u64(8);
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = (__v_10 - __v_16);
+        let __v_18: G = (__v_15 + __v_17);
+        let __v_19: G = (__v_14 + __v_18);
+        let __v_20: G = G::from_u64(0);
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __v_21: G = __r_arr[0];
+        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_38] = [__v_22];
+        if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_39: usize = 2;
+const IN_39: usize = 2;
+const OUT_39: usize = 1;
+fn aiur_fn_39(
+  inp: [G; IN_39],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_39], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -8442,17 +8501,17 @@ fn aiur_fn_38(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_38] = [__v_1];
-        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_39] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[38].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_38(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_38] = unsafe { *(result.output.as_ptr() as *const [G; OUT_38]) }; __ret } } else { aiur_fn_38(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __ret: [G; OUT_38] = [__v_13];
-        if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_39] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8462,16 +8521,17 @@ fn aiur_fn_38(
   })
 }
 
-const INPUT_SIZE_39: usize = 18;
-const IN_39: usize = 18;
-const OUT_39: usize = 8;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_40: usize = 18;
+const IN_40: usize = 18;
+const OUT_40: usize = 8;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], ExecError> {
+) -> Result<[G; OUT_40], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8492,7 +8552,7 @@ fn aiur_fn_39(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8511,7 +8571,7 @@ fn aiur_fn_39(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -8520,7 +8580,7 @@ fn aiur_fn_39(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8529,8 +8589,8 @@ fn aiur_fn_39(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8542,24 +8602,25 @@ fn aiur_fn_39(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_40: usize = 18;
-const IN_40: usize = 18;
-const OUT_40: usize = 8;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+const INPUT_SIZE_41: usize = 18;
+const IN_41: usize = 18;
+const OUT_41: usize = 8;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_40], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8580,7 +8641,7 @@ fn aiur_fn_40(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       8u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8599,7 +8660,7 @@ fn aiur_fn_40(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; 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 { let __r = record.function_queries[41].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -8608,7 +8669,7 @@ fn aiur_fn_40(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8617,8 +8678,8 @@ fn aiur_fn_40(
         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_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8630,24 +8691,25 @@ fn aiur_fn_40(
         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_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_41: usize = 18;
-const IN_41: usize = 18;
-const OUT_41: usize = 8;
-fn aiur_fn_41(
-  inp: [G; IN_41],
+const INPUT_SIZE_42: usize = 18;
+const IN_42: usize = 18;
+const OUT_42: usize = 8;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
+) -> Result<[G; OUT_42], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8668,7 +8730,7 @@ fn aiur_fn_41(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       9u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8687,7 +8749,7 @@ fn aiur_fn_41(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = __r_arr[2];
@@ -8696,7 +8758,7 @@ fn aiur_fn_41(
         let __v_41: G = __r_arr[5];
         let __v_42: G = __r_arr[6];
         let __v_43: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -8705,8 +8767,8 @@ fn aiur_fn_41(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_41] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8718,24 +8780,25 @@ fn aiur_fn_41(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_41] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 19;
-const IN_42: usize = 19;
-const OUT_42: usize = 1;
-fn aiur_fn_42(
-  inp: [G; IN_42],
+const INPUT_SIZE_43: usize = 19;
+const IN_43: usize = 19;
+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_42], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8757,7 +8820,7 @@ fn aiur_fn_42(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8776,7 +8839,7 @@ fn aiur_fn_42(
         let __v_34: G = __loaded[15];
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8795,35 +8858,36 @@ fn aiur_fn_42(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_42] = { let __args: [G; IN_42] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_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[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[43].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
-        let __ret: [G; OUT_42] = [__v_56];
-        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_43] = [__v_56];
+        if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_42] = [__v_19];
-        if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_43] = [__v_19];
+        if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 19;
-const IN_43: usize = 19;
-const OUT_43: usize = 1;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_44: usize = 19;
+const IN_44: usize = 19;
+const OUT_44: usize = 1;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], ExecError> {
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8845,7 +8909,7 @@ fn aiur_fn_43(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       8u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8864,7 +8928,7 @@ fn aiur_fn_43(
         let __v_34: G = __loaded[15];
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8883,35 +8947,36 @@ fn aiur_fn_43(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_43] = [__v_56];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_56];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_43] = [__v_19];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_44] = [__v_19];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 19;
-const IN_44: usize = 19;
-const OUT_44: usize = 1;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_45: usize = 19;
+const IN_45: usize = 19;
+const OUT_45: usize = 1;
+fn aiur_fn_45(
+  inp: [G; IN_45],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
+) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8933,7 +8998,7 @@ fn aiur_fn_44(
     let __v_18: G = inp[18];
     match __v_0.as_canonical_u64() {
       9u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8952,7 +9017,7 @@ fn aiur_fn_44(
         let __v_34: G = __loaded[15];
         let __v_35: G = __loaded[16];
         let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -8971,38 +9036,39 @@ fn aiur_fn_44(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_44(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_44] = unsafe { *(result.output.as_ptr() as *const [G; OUT_44]) }; __ret } } else { aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_44] = [__v_56];
-        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_45] = [__v_56];
+        if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_44] = [__v_19];
-        if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_45] = [__v_19];
+        if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_45: usize = 2;
-const IN_45: usize = 2;
-const OUT_45: usize = 1;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_46: usize = 2;
+const IN_46: usize = 2;
+const OUT_46: usize = 1;
+fn aiur_fn_46(
+  inp: [G; IN_46],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], ExecError> {
+) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -9036,85 +9102,86 @@ fn aiur_fn_45(
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
     let __v_34: G = G::from_u64(0);
-    let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
-    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_38: G = G::from_u64(0);
-    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_40: G = G::from_u64(0);
-    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_42: G = G::from_u64(0);
-    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_46: G = G::from_u64(0);
-    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_48: G = G::from_u64(0);
-    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_50: G = G::from_u64(0);
-    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_52: G = G::from_u64(0);
-    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_54: G = G::from_u64(0);
-    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_56: G = G::from_u64(0);
-    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_58: G = G::from_u64(0);
-    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_60: G = G::from_u64(0);
-    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_62: G = G::from_u64(0);
-    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_64: G = G::from_u64(0);
-    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_66: G = G::from_u64(0);
-    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_68: G = G::from_u64(0);
-    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_70: G = G::from_u64(0);
-    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_72: G = G::from_u64(0);
-    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_74: G = G::from_u64(0);
-    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_76: G = G::from_u64(0);
-    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_78: G = G::from_u64(0);
-    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_80: G = G::from_u64(0);
-    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_82: G = G::from_u64(0);
-    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_84: G = G::from_u64(0);
-    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_86: G = G::from_u64(0);
-    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_88: G = G::from_u64(0);
-    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_90: G = G::from_u64(0);
-    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_92: G = G::from_u64(0);
-    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_94: G = G::from_u64(0);
-    let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_96: G = G::from_u64(0);
-    let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_45] = [__v_97];
-    if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_46] = [__v_97];
+    if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_46: usize = 2;
-const IN_46: usize = 2;
-const OUT_46: usize = 1;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_47: usize = 2;
+const IN_47: usize = 2;
+const OUT_47: usize = 1;
+fn aiur_fn_47(
+  inp: [G; IN_47],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_46], ExecError> {
+) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -9122,20 +9189,20 @@ fn aiur_fn_46(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -9147,20 +9214,20 @@ fn aiur_fn_46(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -9172,20 +9239,20 @@ fn aiur_fn_46(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_46] = [__v_2];
-            if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_47] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -9200,16 +9267,17 @@ fn aiur_fn_46(
   })
 }
 
-const INPUT_SIZE_47: usize = 9;
-const IN_47: usize = 9;
-const OUT_47: usize = 8;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_48: usize = 9;
+const IN_48: usize = 9;
+const OUT_48: usize = 8;
+fn aiur_fn_48(
+  inp: [G; IN_48],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], ExecError> {
+) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9221,7 +9289,7 @@ fn aiur_fn_47(
     let __v_8: G = inp[8];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -9231,7 +9299,7 @@ fn aiur_fn_47(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9240,7 +9308,7 @@ fn aiur_fn_47(
         let __v_23: G = __r_arr[5];
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -9249,8 +9317,8 @@ fn aiur_fn_47(
         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_47] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_48] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9262,24 +9330,25 @@ fn aiur_fn_47(
         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_47] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_48: usize = 9;
-const IN_48: usize = 9;
-const OUT_48: usize = 9;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_49: usize = 9;
+const IN_49: usize = 9;
+const OUT_49: usize = 9;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], ExecError> {
+) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9291,7 +9360,7 @@ fn aiur_fn_48(
     let __v_8: G = inp[8];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -9301,7 +9370,7 @@ fn aiur_fn_48(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; 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 { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9311,29 +9380,30 @@ fn aiur_fn_48(
         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_48] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_49: usize = 10;
-const IN_49: usize = 10;
-const OUT_49: usize = 1;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_50: usize = 10;
+const IN_50: usize = 10;
+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_49], ExecError> {
+) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9348,13 +9418,13 @@ fn aiur_fn_49(
       0u64 => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_49] = [__v_12];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_50] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        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]; let __cu = unconstrained; if let Some(result) = record.function_queries[47].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_47(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_47] = unsafe { *(result.output.as_ptr() as *const [G; OUT_47]) }; __ret } } else { aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -9363,7 +9433,7 @@ fn aiur_fn_49(
         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_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[48].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_48(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } } else { aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[49].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -9374,16 +9444,16 @@ fn aiur_fn_49(
         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_49] = { let __args: [G; IN_49] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_49] = [__v_29];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9393,7 +9463,7 @@ fn aiur_fn_49(
         let __v_16: G = __loaded[6];
         let __v_17: G = __loaded[7];
         let __v_18: G = __loaded[8];
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_19: G = __loaded[0];
         let __v_20: G = __loaded[1];
         let __v_21: G = __loaded[2];
@@ -9412,18 +9482,18 @@ fn aiur_fn_49(
         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_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_49] = [__v_39];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_39];
+        if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9433,7 +9503,7 @@ fn aiur_fn_49(
         let __v_16: G = __loaded[6];
         let __v_17: G = __loaded[7];
         let __v_18: G = __loaded[8];
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_19: G = __loaded[0];
         let __v_20: G = __loaded[1];
         let __v_21: G = __loaded[2];
@@ -9452,22 +9522,22 @@ fn aiur_fn_49(
         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_49] = { let __args: [G; IN_49] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_49] = [__v_39];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_39];
+        if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_49] = [__v_11];
-        if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_50] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9477,30 +9547,31 @@ fn aiur_fn_49(
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
-const OUT_50: usize = 1;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_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_50], ExecError> {
+) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_50] = [__v_1];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_51] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -9519,12 +9590,12 @@ fn aiur_fn_50(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_50] = [__v_24];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_51] = [__v_24];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9534,30 +9605,31 @@ fn aiur_fn_50(
   })
 }
 
-const INPUT_SIZE_51: usize = 2;
-const IN_51: usize = 2;
-const OUT_51: usize = 1;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_52: usize = 2;
+const IN_52: usize = 2;
+const OUT_52: usize = 1;
+fn aiur_fn_52(
+  inp: [G; IN_52],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_51] = [__v_1];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+        let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -9567,12 +9639,12 @@ fn aiur_fn_51(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; 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 { let __r = record.function_queries[52].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_49(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_49] = unsafe { *(result.output.as_ptr() as *const [G; OUT_49]) }; __ret } } else { aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__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[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[50].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-        let __ret: [G; OUT_51] = [__v_15];
-        if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_52] = [__v_15];
+        if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9582,35 +9654,36 @@ fn aiur_fn_51(
   })
 }
 
-const INPUT_SIZE_52: usize = 2;
-const IN_52: usize = 2;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_53: usize = 2;
+const IN_53: usize = 2;
+const OUT_53: usize = 1;
+fn aiur_fn_53(
+  inp: [G; IN_53],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], ExecError> {
+) -> Result<[G; OUT_53], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_52] = [__v_1];
-        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_53] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_6];
-        if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_53] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9620,49 +9693,50 @@ 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_54: usize = 2;
+const IN_54: usize = 2;
+const OUT_54: usize = 1;
+fn aiur_fn_54(
+  inp: [G; IN_54],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_53], ExecError> {
+) -> Result<[G; OUT_54], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_54] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_54] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(2);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_54] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(3);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_54] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9672,16 +9746,17 @@ fn aiur_fn_53(
   })
 }
 
-const INPUT_SIZE_54: usize = 13;
-const IN_54: usize = 13;
-const OUT_54: usize = 1;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+const INPUT_SIZE_55: usize = 13;
+const IN_55: usize = 13;
+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_54], ExecError> {
+) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9697,7 +9772,7 @@ fn aiur_fn_54(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -9716,7 +9791,7 @@ fn aiur_fn_54(
         let __v_28: G = __loaded[15];
         let __v_29: G = __loaded[16];
         let __v_30: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_31: G = __loaded[0];
         let __v_32: G = __loaded[1];
         let __v_33: G = __loaded[2];
@@ -9735,34 +9810,35 @@ fn aiur_fn_54(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_54] = [__v_54];
-        if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_55] = [__v_54];
+        if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_55: usize = 10;
-const IN_55: usize = 10;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_56: usize = 10;
+const IN_56: usize = 10;
+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_55], ExecError> {
+) -> Result<[G; OUT_56], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9775,7 +9851,7 @@ fn aiur_fn_55(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -9794,31 +9870,32 @@ fn aiur_fn_55(
         let __v_25: G = __loaded[15];
         let __v_26: G = __loaded[16];
         let __v_27: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_55] = [__v_29];
-        if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_56] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_56: usize = 2;
-const IN_56: usize = 2;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+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_56], ExecError> {
+) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -9832,17 +9909,17 @@ fn aiur_fn_56(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_56] = [__v_1];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_57] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_12, __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 { let __r = record.function_queries[57].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_55(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_55] = unsafe { *(result.output.as_ptr() as *const [G; OUT_55]) }; __ret } } else { aiur_fn_55(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; 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 { let __r = record.function_queries[56].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_56] = [__v_14];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_57] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -9852,16 +9929,17 @@ fn aiur_fn_56(
   })
 }
 
-const INPUT_SIZE_57: usize = 45;
-const IN_57: usize = 45;
-const OUT_57: usize = 1;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_58: usize = 45;
+const IN_58: usize = 45;
+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_57], ExecError> {
+) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9909,7 +9987,7 @@ fn aiur_fn_57(
     let __v_44: G = inp[44];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_45: G = __loaded[0];
         let __v_46: G = __loaded[1];
         let __v_47: G = __loaded[2];
@@ -9931,7 +10009,7 @@ fn aiur_fn_57(
         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_766] = { let __args: [G; IN_766] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_43]; 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 { let __r = record.function_queries[766].replay_at(__i); record.virt += __r; } 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 __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -9941,41 +10019,42 @@ fn aiur_fn_57(
         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_56] = { let __args: [G; IN_56] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_43, __v_44]; 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 { let __r = record.function_queries[57].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_77: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_57] = [__v_83];
-        if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_58] = [__v_83];
+        if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 11;
-const IN_58: usize = 11;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_59: usize = 11;
+const IN_59: usize = 11;
+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_58], ExecError> {
+) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9989,7 +10068,7 @@ fn aiur_fn_58(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -10009,29 +10088,30 @@ fn aiur_fn_58(
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
         let __v_29: G = G::from_u64(0);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_58] = [__v_32];
-        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_59] = [__v_32];
+        if !unconstrained { record.virt += record.function_queries[59].weight(); } record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 11;
-const IN_59: usize = 11;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_60: usize = 11;
+const IN_60: usize = 11;
+const OUT_60: usize = 1;
+fn aiur_fn_60(
+  inp: [G; IN_60],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_59], ExecError> {
+) -> Result<[G; OUT_60], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10045,7 +10125,7 @@ fn aiur_fn_59(
     let __v_10: G = inp[10];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -10064,30 +10144,31 @@ fn aiur_fn_59(
         let __v_26: G = __loaded[15];
         let __v_27: G = __loaded[16];
         let __v_28: G = __loaded[17];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_53] = { let __args: [G; IN_53] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_30]; 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 { let __r = record.function_queries[54].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-        let __ret: [G; OUT_59] = [__v_31];
-        if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_60] = [__v_31];
+        if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_60: usize = 35;
-const IN_60: usize = 35;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_61: usize = 35;
+const IN_61: usize = 35;
+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_60], ExecError> {
+) -> Result<[G; OUT_61], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10125,7 +10206,7 @@ fn aiur_fn_60(
     let __v_34: G = inp[34];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_35: G = __loaded[0];
         let __v_36: G = __loaded[1];
         let __v_37: G = __loaded[2];
@@ -10145,38 +10226,39 @@ fn aiur_fn_60(
         let __v_51: G = __loaded[16];
         let __v_52: G = __loaded[17];
         let __v_53: G = G::from_u64(0);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_60] = [__v_59];
-        if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_61] = [__v_59];
+        if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 2;
-const IN_61: usize = 2;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_62: usize = 2;
+const IN_62: usize = 2;
+const OUT_62: usize = 1;
+fn aiur_fn_62(
+  inp: [G; IN_62],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_61], ExecError> {
+) -> Result<[G; OUT_62], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -10215,17 +10297,17 @@ fn aiur_fn_61(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_61] = [__v_1];
-        if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_62] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_37, __v_1]; 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 { let __r = record.function_queries[62].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-        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_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_60(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } } else { aiur_fn_60(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; 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 { let __r = record.function_queries[61].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_39];
-        if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_62] = [__v_39];
+        if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -10235,16 +10317,17 @@ fn aiur_fn_61(
   })
 }
 
-const INPUT_SIZE_62: usize = 28;
-const IN_62: usize = 28;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_63: usize = 28;
+const IN_63: usize = 28;
+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_62], ExecError> {
+) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10275,7 +10358,7 @@ fn aiur_fn_62(
     let __v_27: G = inp[27];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
         let __v_28: G = __loaded[0];
         let __v_29: G = __loaded[1];
         let __v_30: G = __loaded[2];
@@ -10294,7 +10377,7 @@ fn aiur_fn_62(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_26]; 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 { let __r = record.function_queries[761].replay_at(__i); record.virt += __r; } 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 __v_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
         let __v_48: G = __r_arr[2];
@@ -10304,37 +10387,38 @@ fn aiur_fn_62(
         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_61] = { let __args: [G; IN_61] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_61(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_61] = unsafe { *(result.output.as_ptr() as *const [G; OUT_61]) }; __ret } } else { aiur_fn_61(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_26, __v_27]; 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 { let __r = record.function_queries[62].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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];
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_62] = [__v_61];
-        if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_63] = [__v_61];
+        if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_63: usize = 10;
-const IN_63: usize = 10;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_64: usize = 10;
+const IN_64: usize = 10;
+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_63], ExecError> {
+) -> Result<[G; OUT_64], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10347,28 +10431,29 @@ fn aiur_fn_63(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_8, __v_9]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_63] = [__v_11];
-        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_64] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_64: usize = 18;
-const IN_64: usize = 18;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_65: usize = 18;
+const IN_65: usize = 18;
+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_64], ExecError> {
+) -> Result<[G; OUT_65], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10389,30 +10474,31 @@ fn aiur_fn_64(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_64] = [__v_20];
-        if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_65] = [__v_20];
+        if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_65: usize = 46;
-const IN_65: usize = 46;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_66: usize = 46;
+const IN_66: usize = 46;
+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_65], ExecError> {
+) -> Result<[G; OUT_66], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10463,31 +10549,31 @@ fn aiur_fn_65(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_65] = [__v_49];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_66] = [__v_49];
+        if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[62].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_62(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_62] = unsafe { *(result.output.as_ptr() as *const [G; OUT_62]) }; __ret } } else { aiur_fn_62(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_11, __v_12, __v_13, __v_14, __v_15, __v_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[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[63].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_65] = [__v_49];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_66] = [__v_49];
+        if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-        let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_65] = [__v_49];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_66] = [__v_49];
+        if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -10497,19 +10583,20 @@ fn aiur_fn_65(
   })
 }
 
-const INPUT_SIZE_66: usize = 2;
-const IN_66: usize = 2;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_67: usize = 2;
+const IN_67: usize = 2;
+const OUT_67: usize = 1;
+fn aiur_fn_67(
+  inp: [G; IN_67],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_66], ExecError> {
+) -> Result<[G; OUT_67], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -10559,17 +10646,17 @@ fn aiur_fn_66(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_66] = [__v_1];
-        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_67] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_48, __v_1]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-        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_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-        let __ret: [G; OUT_66] = [__v_50];
-        if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_67] = [__v_50];
+        if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -10579,16 +10666,17 @@ fn aiur_fn_66(
   })
 }
 
-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_68: usize = 46;
+const IN_68: usize = 46;
+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_67], ExecError> {
+) -> Result<[G; OUT_68], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10637,59 +10725,59 @@ fn aiur_fn_67(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[54].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_54(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_54] = unsafe { *(result.output.as_ptr() as *const [G; OUT_54]) }; __ret } } else { aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[57].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_57(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_57] = unsafe { *(result.output.as_ptr() as *const [G; OUT_57]) }; __ret } } else { aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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 { let __r = record.function_queries[59].replay_at(__i); record.virt += __r; } 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_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[59].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_59(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } } else { aiur_fn_59(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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 { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } 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_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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 { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } 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_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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_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 { let __r = record.function_queries[64].replay_at(__i); record.virt += __r; } 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_67] = [__v_46];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_46];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -10699,19 +10787,20 @@ 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_69: usize = 2;
+const IN_69: usize = 2;
+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_68], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; 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 { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -10720,29 +10809,30 @@ fn aiur_fn_68(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_68] = [__v_11];
-    if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_69] = [__v_11];
+    if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_69: usize = 2;
-const IN_69: usize = 2;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_69], ExecError> {
+) -> Result<[G; OUT_70], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; 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 { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -10751,29 +10841,30 @@ fn aiur_fn_69(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_52(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_52] = unsafe { *(result.output.as_ptr() as *const [G; OUT_52]) }; __ret } } else { aiur_fn_52(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[53].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_69] = [__v_11];
-    if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_70] = [__v_11];
+    if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-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_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_70], ExecError> {
+) -> Result<[G; OUT_71], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0]; 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 { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -10782,26 +10873,27 @@ 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_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[51].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_51(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_51] = unsafe { *(result.output.as_ptr() as *const [G; OUT_51]) }; __ret } } else { aiur_fn_51(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1]; 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 { let __r = record.function_queries[52].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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];
-    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_71] = [__v_11];
+    if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_71: usize = 49;
-const IN_71: usize = 49;
-const OUT_71: usize = 1;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_72: usize = 49;
+const IN_72: usize = 49;
+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_71], ExecError> {
+) -> Result<[G; OUT_72], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -10853,15 +10945,15 @@ fn aiur_fn_71(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_70(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } } else { aiur_fn_70(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_47, __v_48]; 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 { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } 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_69] = { let __args: [G; IN_69] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_46, __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 { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_45, __v_50]; 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 { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_1]; 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 { let __r = record.function_queries[765].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -10871,12 +10963,12 @@ fn aiur_fn_71(
             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_66] = { let __args: [G; IN_66] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_51]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -10889,12 +10981,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
@@ -10907,12 +10999,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
@@ -10925,12 +11017,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
@@ -10943,12 +11035,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
@@ -10961,12 +11053,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           5u64 => {
@@ -10979,12 +11071,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           6u64 => {
@@ -10997,12 +11089,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           7u64 => {
@@ -11015,12 +11107,12 @@ fn aiur_fn_71(
             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_67] = { let __args: [G; IN_67] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-            let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_71] = [__v_62];
-            if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_72] = [__v_62];
+            if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -11032,34 +11124,35 @@ fn aiur_fn_71(
   })
 }
 
-const INPUT_SIZE_72: usize = 1;
-const IN_72: usize = 1;
-const OUT_72: usize = 2;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_73: usize = 1;
+const IN_73: usize = 1;
+const OUT_73: usize = 2;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
+) -> Result<[G; OUT_73], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __ret: [G; OUT_72] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_73] = [__v_2, __v_3];
+        if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_72] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_73] = [__v_4, __v_7];
+        if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11069,16 +11162,17 @@ fn aiur_fn_72(
   })
 }
 
-const INPUT_SIZE_73: usize = 2;
-const IN_73: usize = 2;
-const OUT_73: usize = 9;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_74: usize = 2;
+const IN_74: usize = 2;
+const OUT_74: usize = 9;
+fn aiur_fn_74(
+  inp: [G; IN_74],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_73], ExecError> {
+) -> Result<[G; OUT_74], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
@@ -11091,12 +11185,12 @@ fn aiur_fn_73(
         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_73] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_74] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
+        if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -11104,7 +11198,7 @@ fn aiur_fn_73(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4, __v_6]; 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 { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __v_9: G = __r_arr[2];
@@ -11114,8 +11208,8 @@ fn aiur_fn_73(
             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_73] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_74] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
+            if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -11127,18 +11221,19 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 9;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+const INPUT_SIZE_75: usize = 1;
+const IN_75: usize = 1;
+const OUT_75: usize = 9;
+fn aiur_fn_75(
+  inp: [G; IN_75],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_74], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -11180,8 +11275,8 @@ fn aiur_fn_74(
             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_74] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_75] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
+            if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -11193,7 +11288,7 @@ fn aiur_fn_74(
             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_73] = { let __args: [G; IN_73] = [__v_3, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_31]; 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 { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
             let __v_37: G = __r_arr[2];
@@ -11203,8 +11298,8 @@ fn aiur_fn_74(
             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_74] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
-            if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_75] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -11216,18 +11311,19 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 1;
-const IN_75: usize = 1;
-const OUT_75: usize = 10;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_76: usize = 1;
+const IN_76: usize = 1;
+const OUT_76: usize = 10;
+fn aiur_fn_76(
+  inp: [G; IN_76],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
+) -> Result<[G; OUT_76], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -11266,14 +11362,14 @@ fn aiur_fn_75(
             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_75] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_76] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; 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 { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -11289,8 +11385,8 @@ fn aiur_fn_75(
             if (__v_39 != __v_40) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
             }
-            let __ret: [G; OUT_75] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_76] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -11302,18 +11398,19 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 10;
-fn aiur_fn_76(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_76], ExecError> {
+) -> Result<[G; OUT_77], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -11352,14 +11449,14 @@ fn aiur_fn_76(
             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_76] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_77] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_3, __v_28]; 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 { let __r = record.function_queries[74].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
             let __v_31: G = __r_arr[2];
@@ -11369,8 +11466,8 @@ fn aiur_fn_76(
             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_76] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_77] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -11382,16 +11479,17 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 9;
-const IN_77: usize = 9;
-const OUT_77: usize = 2;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_78: usize = 9;
+const IN_78: usize = 9;
+const OUT_78: usize = 2;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_77], ExecError> {
+) -> Result<[G; OUT_78], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11401,19 +11499,19 @@ fn aiur_fn_77(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_77] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_78] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11423,7 +11521,7 @@ fn aiur_fn_77(
         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_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -11432,13 +11530,13 @@ fn aiur_fn_77(
         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_77] = { let __args: [G; IN_77] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__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[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = G::from_u64(0);
-        let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_77] = [__v_30, __v_28];
-        if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_78] = [__v_30, __v_28];
+        if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11448,16 +11546,17 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 10;
-const IN_78: usize = 10;
-const OUT_78: usize = 2;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+const INPUT_SIZE_79: usize = 10;
+const IN_79: usize = 10;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_78], ExecError> {
+) -> Result<[G; OUT_79], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11468,22 +11567,22 @@ fn aiur_fn_78(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_78] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_79] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_1]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(7);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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];
@@ -11492,11 +11591,11 @@ fn aiur_fn_78(
         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_78] = { let __args: [G; IN_78] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__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[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
         let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_78] = [__v_24, __v_25];
-        if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_79] = [__v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11506,16 +11605,17 @@ 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_80: usize = 9;
+const IN_80: usize = 9;
+const OUT_80: usize = 2;
+fn aiur_fn_80(
+  inp: [G; IN_80],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
+) -> Result<[G; OUT_80], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11525,22 +11625,22 @@ fn aiur_fn_79(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_79] = [__v_10, __v_11];
-        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_80] = [__v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11549,14 +11649,14 @@ fn aiur_fn_79(
         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_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(8);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_79] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_80] = [__v_24, __v_21];
+        if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11566,16 +11666,17 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 9;
-const IN_80: usize = 9;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_81: usize = 9;
+const IN_81: usize = 9;
+const OUT_81: usize = 2;
+fn aiur_fn_81(
+  inp: [G; IN_81],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_81], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11585,22 +11686,22 @@ fn aiur_fn_80(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __ret: [G; OUT_80] = [__v_10, __v_11];
-        if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_81] = [__v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -11609,14 +11710,14 @@ fn aiur_fn_80(
         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_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(9);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_80] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_10, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_81] = [__v_24, __v_21];
+        if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11626,18 +11727,19 @@ fn aiur_fn_80(
   })
 }
 
-const INPUT_SIZE_81: usize = 1;
-const IN_81: usize = 1;
-const OUT_81: usize = 2;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_82: usize = 1;
+const IN_82: usize = 1;
+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_81], ExecError> {
+) -> Result<[G; OUT_82], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -11652,21 +11754,21 @@ fn aiur_fn_81(
       0u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_13, __v_10];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_13, __v_10];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11676,18 +11778,18 @@ fn aiur_fn_81(
         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_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__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[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_24, __v_21];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11697,18 +11799,18 @@ fn aiur_fn_81(
         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_77] = { let __args: [G; IN_77] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__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[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(3);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_24, __v_21];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_24, __v_21];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_10]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -11718,90 +11820,90 @@ fn aiur_fn_81(
         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_81] = { let __args: [G; IN_81] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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(4);
-        let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_23, __v_21];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(5);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_13, __v_10];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(6);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_13, __v_10];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
         if (__v_13 != __v_14) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) });
         }
-        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11, __v_12, __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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
-        let __ret: [G; OUT_81] = [__v_15, __v_16];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_82] = [__v_15, __v_16];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         if (__v_11 != __v_12) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) });
         }
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_81] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_82] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
         if (__v_11 != __v_12) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) });
         }
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_81] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_82] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_81] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_82] = [__v_11, __v_12];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       11u64 => {
         let __v_11: G = G::from_u64(11);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_81] = [__v_13, __v_10];
-        if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_82] = [__v_13, __v_10];
+        if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11811,16 +11913,17 @@ fn aiur_fn_81(
   })
 }
 
-const INPUT_SIZE_82: usize = 9;
-const IN_82: usize = 9;
-const OUT_82: usize = 2;
-fn aiur_fn_82(
-  inp: [G; IN_82],
+const INPUT_SIZE_83: usize = 9;
+const IN_83: usize = 9;
+const OUT_83: usize = 2;
+fn aiur_fn_83(
+  inp: [G; IN_83],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
+) -> Result<[G; OUT_83], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11830,34 +11933,35 @@ fn aiur_fn_82(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
     let __v_15: G = G::from_u64(10);
     let __v_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_82] = [__v_17, __v_14];
-    if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_17: G = { let __values: [G; 18] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_83] = [__v_17, __v_14];
+    if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_83: usize = 17;
-const IN_83: usize = 17;
-const OUT_83: usize = 9;
-fn aiur_fn_83(
-  inp: [G; IN_83],
+const INPUT_SIZE_84: usize = 17;
+const IN_84: usize = 17;
+const OUT_84: usize = 9;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11875,16 +11979,16 @@ fn aiur_fn_83(
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_84] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __v_19: G = __r_arr[1];
         let __v_20: G = __r_arr[2];
@@ -11893,7 +11997,7 @@ fn aiur_fn_83(
         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_83] = { let __args: [G; IN_83] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__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[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
         let __v_27: G = __r_arr[1];
         let __v_28: G = __r_arr[2];
@@ -11904,10 +12008,10 @@ fn aiur_fn_83(
         let __v_33: G = __r_arr[7];
         let __v_34: G = __r_arr[8];
         let __v_35: G = G::from_u64(1);
-        let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_83] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_84] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+        if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11917,18 +12021,19 @@ fn aiur_fn_83(
   })
 }
 
-const INPUT_SIZE_84: usize = 1;
-const IN_84: usize = 1;
-const OUT_84: usize = 10;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+const INPUT_SIZE_85: usize = 1;
+const IN_85: usize = 1;
+const OUT_85: usize = 10;
+fn aiur_fn_85(
+  inp: [G; IN_85],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_84], ExecError> {
+) -> Result<[G; OUT_85], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -11941,18 +12046,18 @@ fn aiur_fn_84(
     let __v_10: G = __r_arr[9];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         match __v_11.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_84] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_85] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
+            if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[2];
@@ -11963,7 +12068,7 @@ fn aiur_fn_84(
             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_83] = { let __args: [G; IN_83] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__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[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[84].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             let __v_23: G = __r_arr[1];
             let __v_24: G = __r_arr[2];
@@ -11973,8 +12078,8 @@ fn aiur_fn_84(
             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_84] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_85] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
+            if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -11983,7 +12088,7 @@ fn aiur_fn_84(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -11994,7 +12099,7 @@ fn aiur_fn_84(
         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_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -12006,15 +12111,15 @@ fn aiur_fn_84(
         let __v_29: G = __r_arr[8];
         let __v_30: G = __r_arr[9];
         let __v_31: G = G::from_u64(2);
-        let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_34: G = G::from_u64(0);
-        let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -12025,7 +12130,7 @@ fn aiur_fn_84(
         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_84] = { let __args: [G; IN_84] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_20]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -12037,17 +12142,17 @@ fn aiur_fn_84(
         let __v_29: G = __r_arr[8];
         let __v_30: G = __r_arr[9];
         let __v_31: G = G::from_u64(3);
-        let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_34: G = G::from_u64(0);
-        let __ret: [G; OUT_84] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_84] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_85] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12057,212 +12162,213 @@ 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_86: usize = 1;
+const IN_86: usize = 1;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 let __v_12: G = __loaded[2];
                 match __v_10.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                     let __v_13: G = __loaded[0];
                     let __v_14: G = __loaded[1];
                     let __v_15: G = __loaded[2];
                     match __v_13.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                         let __v_16: G = __loaded[0];
                         let __v_17: G = __loaded[1];
                         let __v_18: G = __loaded[2];
                         match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                             let __v_19: G = __loaded[0];
                             let __v_20: G = __loaded[1];
                             let __v_21: G = __loaded[2];
                             match __v_19.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                 let __v_22: G = __loaded[0];
                                 let __v_23: G = __loaded[1];
                                 let __v_24: G = __loaded[2];
                                 match __v_22.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                                     let __v_26: G = __loaded[1];
                                     let __v_27: G = __loaded[2];
                                     match __v_25.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                         let __v_28: G = __loaded[0];
                                         let __v_29: G = __loaded[1];
                                         let __v_30: G = __loaded[2];
                                         match __v_28.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                             let __v_31: G = __loaded[0];
                                             let __v_32: G = __loaded[1];
                                             let __v_33: G = __loaded[2];
                                             match __v_31.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                 let __v_34: G = __loaded[0];
                                                 let __v_35: G = __loaded[1];
                                                 let __v_36: G = __loaded[2];
                                                 match __v_34.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                     let __v_37: G = __loaded[0];
                                                     let __v_38: G = __loaded[1];
                                                     let __v_39: G = __loaded[2];
                                                     match __v_37.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                         let __v_40: G = __loaded[0];
                                                         let __v_41: G = __loaded[1];
                                                         let __v_42: G = __loaded[2];
                                                         match __v_40.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                             let __v_43: G = __loaded[0];
                                                             let __v_44: G = __loaded[1];
                                                             let __v_45: G = __loaded[2];
                                                             match __v_43.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                 let __v_46: G = __loaded[0];
                                                                 let __v_47: G = __loaded[1];
                                                                 let __v_48: G = __loaded[2];
                                                                 match __v_46.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                     let __v_49: G = __loaded[0];
                                                                     let __v_50: G = __loaded[1];
                                                                     let __v_51: G = __loaded[2];
                                                                     match __v_49.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                         let __v_52: G = __loaded[0];
                                                                         let __v_53: G = __loaded[1];
                                                                         let __v_54: G = __loaded[2];
                                                                         match __v_52.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                             let __v_55: G = __loaded[0];
                                                                             let __v_56: G = __loaded[1];
                                                                             let __v_57: G = __loaded[2];
                                                                             match __v_55.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                 let __v_58: G = __loaded[0];
                                                                                 let __v_59: G = __loaded[1];
                                                                                 let __v_60: G = __loaded[2];
                                                                                 match __v_58.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                     let __v_61: G = __loaded[0];
                                                                                     let __v_62: G = __loaded[1];
                                                                                     let __v_63: G = __loaded[2];
                                                                                     match __v_61.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                         let __v_64: G = __loaded[0];
                                                                                         let __v_65: G = __loaded[1];
                                                                                         let __v_66: G = __loaded[2];
                                                                                         match __v_64.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                             let __v_67: G = __loaded[0];
                                                                                             let __v_68: G = __loaded[1];
                                                                                             let __v_69: G = __loaded[2];
                                                                                             match __v_67.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                 let __v_70: G = __loaded[0];
                                                                                                 let __v_71: G = __loaded[1];
                                                                                                 let __v_72: G = __loaded[2];
                                                                                                 match __v_70.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                     let __v_73: G = __loaded[0];
                                                                                                     let __v_74: G = __loaded[1];
                                                                                                     let __v_75: G = __loaded[2];
                                                                                                     match __v_73.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                         let __v_76: G = __loaded[0];
                                                                                                         let __v_77: G = __loaded[1];
                                                                                                         let __v_78: G = __loaded[2];
                                                                                                         match __v_76.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                             let __v_79: G = __loaded[0];
                                                                                                             let __v_80: G = __loaded[1];
                                                                                                             let __v_81: G = __loaded[2];
                                                                                                             match __v_79.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                 let __v_82: G = __loaded[0];
                                                                                                                 let __v_83: G = __loaded[1];
                                                                                                                 let __v_84: G = __loaded[2];
                                                                                                                 match __v_82.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                     let __v_85: G = __loaded[0];
                                                                                                                     let __v_86: G = __loaded[1];
                                                                                                                     let __v_87: G = __loaded[2];
                                                                                                                     match __v_85.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                         let __v_88: G = __loaded[0];
                                                                                                                         let __v_89: G = __loaded[1];
                                                                                                                         let __v_90: G = __loaded[2];
                                                                                                                         match __v_88.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                             let __v_91: G = __loaded[0];
                                                                                                                             let __v_92: G = __loaded[1];
                                                                                                                             let __v_93: G = __loaded[2];
                                                                                                                             match __v_91.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                 let __v_94: G = __loaded[0];
                                                                                                                                 let __v_95: G = __loaded[1];
                                                                                                                                 let __v_96: G = __loaded[2];
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
-                                                                                                                                    let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                                                                                                    let __ret: [G; OUT_85] = [__v_97, __v_96];
-                                                                                                                                    if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                                                                                                    let __ret: [G; OUT_86] = [__v_97, __v_96];
+                                                                                                                                    if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -12427,16 +12533,17 @@ 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_87: usize = 9;
+const IN_87: usize = 9;
+const OUT_87: usize = 2;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_87], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12446,22 +12553,22 @@ fn aiur_fn_86(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -12470,13 +12577,13 @@ fn aiur_fn_86(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__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[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_23, __v_21];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12486,16 +12593,17 @@ fn aiur_fn_86(
   })
 }
 
-const INPUT_SIZE_87: usize = 9;
-const IN_87: usize = 9;
-const OUT_87: usize = 2;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_88: usize = 9;
+const IN_88: usize = 9;
+const OUT_88: usize = 2;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12505,19 +12613,19 @@ fn aiur_fn_87(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_87] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_88] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12528,7 +12636,7 @@ fn aiur_fn_87(
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
         let __v_19: G = __r_arr[9];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -12537,14 +12645,14 @@ fn aiur_fn_87(
         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_87] = { let __args: [G; IN_87] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__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[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = G::from_u64(0);
-        let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_87] = [__v_32, __v_29];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_88] = [__v_32, __v_29];
+        if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12554,16 +12662,17 @@ fn aiur_fn_87(
   })
 }
 
-const INPUT_SIZE_88: usize = 9;
-const IN_88: usize = 9;
-const OUT_88: usize = 2;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_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_88], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12573,22 +12682,22 @@ fn aiur_fn_88(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_88] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -12597,13 +12706,13 @@ fn aiur_fn_88(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__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[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_88] = [__v_23, __v_21];
-        if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_23, __v_21];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12613,36 +12722,6 @@ 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],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_89], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __v_3: G = __r_arr[2];
-    let __v_4: G = __r_arr[3];
-    let __v_5: G = __r_arr[4];
-    let __v_6: G = __r_arr[5];
-    let __v_7: G = __r_arr[6];
-    let __v_8: G = __r_arr[7];
-    let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_89] = [__v_10, __v_11];
-    if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_90: usize = 1;
 const IN_90: usize = 1;
 const OUT_90: usize = 2;
@@ -12653,8 +12732,9 @@ fn aiur_fn_90(
   unconstrained: bool,
 ) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12664,11 +12744,11 @@ fn aiur_fn_90(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__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[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_90] = [__v_10, __v_11];
-    if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -12683,8 +12763,9 @@ fn aiur_fn_91(
   unconstrained: bool,
 ) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12694,11 +12775,11 @@ fn aiur_fn_91(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __ret: [G; OUT_91] = [__v_10, __v_11];
-    if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -12713,69 +12794,101 @@ fn aiur_fn_92(
   unconstrained: bool,
 ) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __v_3: G = __r_arr[2];
+    let __v_4: G = __r_arr[3];
+    let __v_5: G = __r_arr[4];
+    let __v_6: G = __r_arr[5];
+    let __v_7: G = __r_arr[6];
+    let __v_8: G = __r_arr[7];
+    let __v_9: G = __r_arr[8];
+    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __ret: [G; OUT_92] = [__v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 2;
+fn aiur_fn_93(
+  inp: [G; IN_93],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_93], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       9u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       10u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_92] = [__v_1, __v_2];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_93] = [__v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12785,24 +12898,25 @@ fn aiur_fn_92(
   })
 }
 
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 13;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 13;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_94], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -12812,30 +12926,31 @@ fn aiur_fn_93(
     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_81] = { let __args: [G; IN_81] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_13]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_15]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_93] = [__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];
-    if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_94] = [__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];
+    if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 10;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_95: usize = 1;
+const IN_95: usize = 1;
+const OUT_95: usize = 10;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12845,25 +12960,26 @@ 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_81] = { let __args: [G; IN_81] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_94] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_95] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 9;
-const IN_95: usize = 9;
-const OUT_95: usize = 2;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+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_95], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12873,19 +12989,19 @@ fn aiur_fn_95(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_95] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_96] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -12895,10 +13011,10 @@ fn aiur_fn_95(
         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_81] = { let __args: [G; IN_81] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
         let __v_22: G = __r_arr[1];
         let __v_23: G = __r_arr[2];
@@ -12907,13 +13023,13 @@ fn aiur_fn_95(
         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_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[96].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = G::from_u64(0);
-        let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_95] = [__v_32, __v_30];
-        if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_96] = [__v_32, __v_30];
+        if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -12923,18 +13039,19 @@ fn aiur_fn_95(
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 45;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 45;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_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) };
@@ -12946,7 +13063,7 @@ fn aiur_fn_96(
     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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -12956,7 +13073,7 @@ fn aiur_fn_96(
     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_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -12966,7 +13083,7 @@ fn aiur_fn_96(
     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_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -12976,7 +13093,7 @@ fn aiur_fn_96(
     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_74] = { let __args: [G; IN_74] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_37]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -12986,7 +13103,7 @@ fn aiur_fn_96(
     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_74] = { let __args: [G; IN_74] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_46]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
     let __v_49: G = __r_arr[2];
@@ -12996,10 +13113,10 @@ fn aiur_fn_96(
     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_81] = { let __args: [G; IN_81] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_55]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
     let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_57]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_58: G = __r_arr[0];
     let __v_59: G = __r_arr[1];
     let __v_60: G = __r_arr[2];
@@ -13009,25 +13126,26 @@ fn aiur_fn_96(
     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_95] = { let __args: [G; IN_95] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__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[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[96].replay_at(__i); record.virt += __r; } 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_67: G = __r_arr[0];
     let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_96] = [__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];
-    if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_97] = [__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];
+    if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 0;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 0;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(2);
     let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) };
@@ -13035,28 +13153,29 @@ fn aiur_fn_97(
     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_97] = [];
-    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_98] = [];
+    if !unconstrained { record.virt += record.function_queries[98].weight(); } record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 11;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 11;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13066,49 +13185,50 @@ fn aiur_fn_98(
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
     let __v_11: G = __r_arr[8];
-    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_11]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    let __ret: [G; OUT_98] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
-    if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_99] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
+    if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 1;
-const IN_99: usize = 1;
-const OUT_99: usize = 1;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 1;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_99] = [__v_1];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_100] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_99] = [__v_1];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_100] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_99] = [__v_1];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_100] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_99] = [__v_1];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_100] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13118,23 +13238,24 @@ fn aiur_fn_99(
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 11;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 11;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -13144,31 +13265,32 @@ fn aiur_fn_100(
     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_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_12]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_100] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
-    if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
+    if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_101: usize = 1;
-const IN_101: usize = 1;
-const OUT_101: usize = 35;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_102: usize = 1;
+const IN_102: usize = 1;
+const OUT_102: usize = 35;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_97(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } } else { aiur_fn_97(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13178,7 +13300,7 @@ fn aiur_fn_101(
     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_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -13188,7 +13310,7 @@ fn aiur_fn_101(
     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_74] = { let __args: [G; IN_74] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_20]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -13198,7 +13320,7 @@ fn aiur_fn_101(
     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_74] = { let __args: [G; IN_74] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_29]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -13208,25 +13330,26 @@ fn aiur_fn_101(
     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_81] = { let __args: [G; IN_81] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_38]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_101] = [__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];
-    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40];
+    if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_102: usize = 9;
-const IN_102: usize = 9;
-const OUT_102: usize = 2;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_103: usize = 9;
+const IN_103: usize = 9;
+const OUT_103: usize = 2;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13236,19 +13359,19 @@ fn aiur_fn_102(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_102] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_103] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_0]; 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 { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13284,7 +13407,7 @@ fn aiur_fn_102(
         let __v_42: G = __r_arr[32];
         let __v_43: G = __r_arr[33];
         let __v_44: G = __r_arr[34];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -13293,13 +13416,13 @@ fn aiur_fn_102(
         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_102] = { let __args: [G; IN_102] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; 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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_53: G = __r_arr[0];
         let __v_54: G = __r_arr[1];
         let __v_55: G = G::from_u64(0);
-        let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_102] = [__v_56, __v_54];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_103] = [__v_56, __v_54];
+        if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13309,18 +13432,19 @@ fn aiur_fn_102(
   })
 }
 
-const INPUT_SIZE_103: usize = 1;
-const IN_103: usize = 1;
-const OUT_103: usize = 28;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_104: usize = 1;
+const IN_104: usize = 1;
+const OUT_104: usize = 28;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_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) };
@@ -13332,7 +13456,7 @@ fn aiur_fn_103(
     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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13342,7 +13466,7 @@ fn aiur_fn_103(
     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_74] = { let __args: [G; IN_74] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_19]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -13352,7 +13476,7 @@ fn aiur_fn_103(
     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_74] = { let __args: [G; IN_74] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -13362,10 +13486,10 @@ fn aiur_fn_103(
     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_81] = { let __args: [G; IN_81] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[81].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_81(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_81] = unsafe { *(result.output.as_ptr() as *const [G; OUT_81]) }; __ret } } else { aiur_fn_81(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_39]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
     let __v_42: G = __r_arr[2];
@@ -13375,27 +13499,28 @@ fn aiur_fn_103(
     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_102] = { let __args: [G; IN_102] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; 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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_103] = [__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];
-    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_104] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50];
+    if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 10;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 10;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13405,27 +13530,28 @@ fn aiur_fn_104(
     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; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_104] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 1;
-const IN_105: usize = 1;
-const OUT_105: usize = 18;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_106: usize = 1;
+const IN_106: usize = 1;
+const OUT_106: usize = 18;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13435,7 +13561,7 @@ fn aiur_fn_105(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_9]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -13445,32 +13571,33 @@ fn aiur_fn_105(
     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; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_18]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_105] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
-    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_106] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
+    if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_106: usize = 1;
-const IN_106: usize = 1;
-const OUT_106: usize = 46;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 46;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -13486,12 +13613,12 @@ fn aiur_fn_106(
         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_106] = [__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];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_107] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
+        if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_2]; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -13522,12 +13649,12 @@ fn aiur_fn_106(
         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_106] = [__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];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_107] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
+        if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[97].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -13574,8 +13701,8 @@ fn aiur_fn_106(
         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_106] = [__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];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_107] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
+        if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13585,16 +13712,17 @@ fn aiur_fn_106(
   })
 }
 
-const INPUT_SIZE_107: usize = 9;
-const IN_107: usize = 9;
-const OUT_107: usize = 2;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_108: usize = 9;
+const IN_108: usize = 9;
+const OUT_108: usize = 2;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13604,19 +13732,19 @@ fn aiur_fn_107(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_107] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_108] = [__v_12, __v_0];
+        if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_106(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } } else { aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0]; 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 { let __r = record.function_queries[107].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13663,7 +13791,7 @@ fn aiur_fn_107(
         let __v_53: G = __r_arr[43];
         let __v_54: G = __r_arr[44];
         let __v_55: G = __r_arr[45];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -13672,13 +13800,13 @@ fn aiur_fn_107(
         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_107] = { let __args: [G; IN_107] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; 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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = G::from_u64(0);
-        let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_107] = [__v_67, __v_65];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_108] = [__v_67, __v_65];
+        if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13688,21 +13816,22 @@ fn aiur_fn_107(
   })
 }
 
-const INPUT_SIZE_108: usize = 2;
-const IN_108: usize = 2;
-const OUT_108: usize = 46;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_109: usize = 2;
+const IN_109: usize = 2;
+const OUT_109: usize = 46;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_93(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } } else { aiur_fn_93(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -13718,12 +13847,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_96(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } } else { aiur_fn_96(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[97].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13770,12 +13899,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1]; 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 { let __r = record.function_queries[99].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13789,12 +13918,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13808,12 +13937,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -13834,12 +13963,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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];
@@ -13852,12 +13981,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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];
@@ -13870,12 +13999,12 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_104(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } } else { aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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];
@@ -13888,8 +14017,8 @@ fn aiur_fn_108(
         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_108] = [__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];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13899,16 +14028,17 @@ fn aiur_fn_108(
   })
 }
 
-const INPUT_SIZE_109: usize = 10;
-const IN_109: usize = 10;
-const OUT_109: usize = 46;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_110: usize = 10;
+const IN_110: usize = 10;
+const OUT_110: usize = 46;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
+) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13921,13 +14051,13 @@ fn aiur_fn_109(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_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_109] = [__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];
-        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       13u64 => {
@@ -13941,7 +14071,7 @@ fn aiur_fn_109(
         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_108] = { let __args: [G; IN_108] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1, __v_9]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -13988,8 +14118,8 @@ fn aiur_fn_109(
         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_109] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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];
-        if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -13999,18 +14129,19 @@ fn aiur_fn_109(
   })
 }
 
-const INPUT_SIZE_110: usize = 1;
-const IN_110: usize = 1;
-const OUT_110: usize = 49;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_111: usize = 1;
+const IN_111: usize = 1;
+const OUT_111: usize = 49;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
+) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -14023,7 +14154,7 @@ fn aiur_fn_110(
     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_107] = { let __args: [G; IN_107] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__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[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = G::from_u64(8);
@@ -14041,7 +14172,7 @@ fn aiur_fn_110(
     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_108] = { let __args: [G; IN_108] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2, __v_10]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
@@ -14141,7 +14272,7 @@ fn aiur_fn_110(
     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_74] = { let __args: [G; IN_74] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_56]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
     let __v_58: G = __r_arr[1];
     let __v_59: G = __r_arr[2];
@@ -14151,10 +14282,10 @@ fn aiur_fn_110(
     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_86] = { let __args: [G; IN_86] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__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[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_66: G = __r_arr[0];
     let __v_67: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_67]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_68: G = __r_arr[0];
     let __v_69: G = __r_arr[1];
     let __v_70: G = __r_arr[2];
@@ -14164,10 +14295,10 @@ fn aiur_fn_110(
     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_88] = { let __args: [G; IN_88] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_88(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } } else { aiur_fn_88(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__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[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_77: G = __r_arr[0];
     let __v_78: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_78]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
     let __v_80: G = __r_arr[1];
     let __v_81: G = __r_arr[2];
@@ -14177,66 +14308,68 @@ fn aiur_fn_110(
     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_87] = { let __args: [G; IN_87] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__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[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[88].replay_at(__i); record.virt += __r; } 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_88: G = __r_arr[0];
     let __v_89: G = __r_arr[1];
-    let __ret: [G; OUT_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_66, __v_77, __v_88, __v_89];
-    if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_111] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89];
+    if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_111: usize = 1;
-const IN_111: usize = 1;
-const OUT_111: usize = 2;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 2;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6, __v_3]; 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 { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_111] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_112] = [__v_5, __v_7];
+        if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_111] = [__v_0, __v_7];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_112] = [__v_0, __v_7];
+        if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_112: usize = 1;
-const IN_112: usize = 1;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 1;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -14260,10 +14393,10 @@ fn aiur_fn_112(
         let __v_19: G = G::from_u64(0);
         let __v_20: G = G::from_u64(1);
         let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_112] = [__v_23];
-        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_113] = [__v_23];
+        if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -14275,7 +14408,7 @@ fn aiur_fn_112(
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -14288,18 +14421,18 @@ fn aiur_fn_112(
         match __v_27.as_canonical_u64() {
           0u64 => {
             let __v_28: G = G::from_u64(0);
-            let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_112] = [__v_29];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_113] = [__v_29];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-            let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_112] = [__v_30];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_113] = [__v_30];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -14311,20 +14444,21 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 3;
-const IN_113: usize = 3;
-const OUT_113: usize = 1;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_114: usize = 3;
+const IN_114: usize = 3;
+const OUT_114: usize = 1;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -14339,21 +14473,21 @@ fn aiur_fn_113(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_113] = [__v_1];
-            if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_114] = [__v_1];
+            if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-            let __ret: [G; OUT_113] = [__v_13];
-            if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_114] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -14368,21 +14502,21 @@ fn aiur_fn_113(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_113] = [__v_0];
-                if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_114] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_113] = [__v_23];
-                if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_114] = [__v_23];
+                if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__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];
@@ -14399,7 +14533,7 @@ fn aiur_fn_113(
             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_13] = { let __args: [G; IN_13] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__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];
@@ -14411,11 +14545,11 @@ fn aiur_fn_113(
             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_113] = { let __args: [G; IN_113] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_12, __v_22, __v_48]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-            let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_113] = [__v_51];
-            if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_114] = [__v_51];
+            if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -14430,37 +14564,39 @@ fn aiur_fn_113(
   })
 }
 
-const INPUT_SIZE_114: usize = 2;
-const IN_114: usize = 2;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_115: usize = 2;
+const IN_115: usize = 2;
+const OUT_115: usize = 1;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_113] = { let __args: [G; IN_113] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_114] = [__v_3];
-    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_115] = [__v_3];
+    if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_115: usize = 16;
-const IN_115: usize = 16;
-const OUT_115: usize = 9;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_116: usize = 16;
+const IN_116: usize = 16;
+const OUT_116: usize = 9;
+fn aiur_fn_116(
+  inp: [G; IN_116],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], ExecError> {
+) -> Result<[G; OUT_116], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -14529,26 +14665,27 @@ fn aiur_fn_115(
     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_115] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_116] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_116: usize = 3;
-const IN_116: usize = 3;
-const OUT_116: usize = 2;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_117: usize = 3;
+const IN_117: usize = 3;
+const OUT_117: usize = 2;
+fn aiur_fn_117(
+  inp: [G; IN_117],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_116], ExecError> {
+) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -14561,7 +14698,7 @@ fn aiur_fn_116(
     let __v_12: G = __loaded[9];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -14576,30 +14713,30 @@ fn aiur_fn_116(
           1u64 => {
             let __v_23: G = G::from_u64(1);
             let __v_24: G = G::from_u64(1);
-            let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_116] = [__v_25, __v_2];
-            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_117] = [__v_25, __v_2];
+            if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_116] = [__v_26, __v_2];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_117] = [__v_26, __v_2];
+                if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_27: G = G::from_u64(1);
-                let __ret: [G; OUT_116] = [__v_26, __v_27];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_117] = [__v_26, __v_27];
+                if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -14610,7 +14747,7 @@ fn aiur_fn_116(
         }
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -14626,8 +14763,8 @@ fn aiur_fn_116(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_116] = [__v_0, __v_23];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_117] = [__v_0, __v_23];
+                if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -14639,7 +14776,7 @@ fn aiur_fn_116(
                 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_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
                 let __v_32: G = __r_arr[1];
                 let __v_33: G = __r_arr[2];
@@ -14651,20 +14788,20 @@ fn aiur_fn_116(
                 let __v_39: G = __r_arr[8];
                 let __v_40: G = G::from_u64(1);
                 let __v_41: G = G::from_u64(1);
-                let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_42, __v_39]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
                 let __v_44: G = __r_arr[1];
                 let __v_45: G = G::from_u64(0);
-                let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_116] = [__v_46, __v_44];
-                if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_117] = [__v_46, __v_44];
+                if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -14681,7 +14818,7 @@ fn aiur_fn_116(
             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_115] = { let __args: [G; IN_115] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__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[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
             let __v_41: G = __r_arr[2];
@@ -14692,13 +14829,13 @@ fn aiur_fn_116(
             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_116] = { let __args: [G; IN_116] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
             let __v_51: G = G::from_u64(0);
-            let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_116] = [__v_52, __v_50];
-            if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_117] = [__v_52, __v_50];
+            if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -14713,18 +14850,19 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 1;
-const IN_117: usize = 1;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_118: usize = 1;
+const IN_118: usize = 1;
+const OUT_118: usize = 1;
+fn aiur_fn_118(
+  inp: [G; IN_118],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_117], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -14739,9 +14877,9 @@ fn aiur_fn_117(
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_117] = [__v_13];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_118] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -14750,11 +14888,11 @@ fn aiur_fn_117(
         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_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_117] = [__v_13];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_118] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -14764,18 +14902,19 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 1;
-const IN_118: usize = 1;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_119: usize = 1;
+const IN_119: usize = 1;
+const OUT_119: usize = 1;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], ExecError> {
+) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -14790,15 +14929,15 @@ fn aiur_fn_118(
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_118] = [__v_13];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_119] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -14811,25 +14950,25 @@ fn aiur_fn_118(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = G::from_u64(1);
-                let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_118] = [__v_25];
-                if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_119] = [__v_25];
+                if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = G::from_u64(1);
-                let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_118] = [__v_27];
-                if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_119] = [__v_27];
+                if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -14839,9 +14978,9 @@ fn aiur_fn_118(
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_118] = [__v_23];
-            if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_119] = [__v_23];
+            if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -14853,36 +14992,37 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 2;
-const IN_119: usize = 2;
-const OUT_119: usize = 1;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_120: usize = 2;
+const IN_120: usize = 2;
+const OUT_120: usize = 1;
+fn aiur_fn_120(
+  inp: [G; IN_120],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_120], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_119] = [__v_7];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_120] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_119] = [__v_5];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_120] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -14892,21 +15032,22 @@ fn aiur_fn_119(
   })
 }
 
-const INPUT_SIZE_120: usize = 2;
-const IN_120: usize = 2;
-const OUT_120: usize = 1;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_121: usize = 2;
+const IN_121: usize = 2;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> Result<[G; OUT_121], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -14920,30 +15061,31 @@ fn aiur_fn_120(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_120] = [__v_13];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_120] = [__v_13];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_121] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-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_122: usize = 1;
+const IN_122: usize = 1;
+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_121], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(1);
@@ -14956,34 +15098,35 @@ fn aiur_fn_121(
     let __v_9: G = G::from_u64(0);
     let __v_10: G = G::from_u64(1);
     let __v_11: G = G::from_u64(1);
-    let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_13]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_121] = [__v_14];
-    if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_122] = [__v_14];
+    if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_122: usize = 2;
-const IN_122: usize = 2;
-const OUT_122: usize = 2;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_123: usize = 2;
+const IN_123: usize = 2;
+const OUT_123: usize = 2;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(256);
     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_122] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -14991,11 +15134,11 @@ fn aiur_fn_122(
         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_122] = { let __args: [G; IN_122] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_122] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_8, __v_9];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15005,41 +15148,43 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 1;
-const IN_123: usize = 1;
-const OUT_123: usize = 3;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_124: usize = 1;
+const IN_124: usize = 1;
+const OUT_124: usize = 3;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_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_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_123] = [__v_2, __v_5, __v_6];
-    if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_124] = [__v_2, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_124: usize = 16;
-const IN_124: usize = 16;
-const OUT_124: usize = 16;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_125: usize = 16;
+const IN_125: usize = 16;
+const OUT_125: usize = 16;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_124], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -15169,7 +15314,7 @@ fn aiur_fn_124(
     let __v_126: G = (__v_7 * __v_14);
     let __v_127: G = (__v_125 + __v_126);
     let __v_128: G = (__v_7 * __v_15);
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -15192,7 +15337,7 @@ fn aiur_fn_124(
     if (__v_16 != __v_147) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_141]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_141]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_148: G = __r_arr[0];
     let __v_149: G = __r_arr[1];
     let __v_150: G = __r_arr[2];
@@ -15215,7 +15360,7 @@ fn aiur_fn_124(
     if (__v_141 != __v_166) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_160]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_160]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_167: G = __r_arr[0];
     let __v_168: G = __r_arr[1];
     let __v_169: G = __r_arr[2];
@@ -15238,7 +15383,7 @@ fn aiur_fn_124(
     if (__v_160 != __v_185) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_179]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_179]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_186: G = __r_arr[0];
     let __v_187: G = __r_arr[1];
     let __v_188: G = __r_arr[2];
@@ -15261,7 +15406,7 @@ fn aiur_fn_124(
     if (__v_179 != __v_204) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_198]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_198]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_205: G = __r_arr[0];
     let __v_206: G = __r_arr[1];
     let __v_207: G = __r_arr[2];
@@ -15284,7 +15429,7 @@ fn aiur_fn_124(
     if (__v_198 != __v_223) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_217]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_217]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_224: G = __r_arr[0];
     let __v_225: G = __r_arr[1];
     let __v_226: G = __r_arr[2];
@@ -15307,7 +15452,7 @@ fn aiur_fn_124(
     if (__v_217 != __v_242) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_236]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_236]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_243: G = __r_arr[0];
     let __v_244: G = __r_arr[1];
     let __v_245: G = __r_arr[2];
@@ -15330,7 +15475,7 @@ fn aiur_fn_124(
     if (__v_236 != __v_261) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_255]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_255]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_262: G = __r_arr[0];
     let __v_263: G = __r_arr[1];
     let __v_264: G = __r_arr[2];
@@ -15353,7 +15498,7 @@ fn aiur_fn_124(
     if (__v_255 != __v_280) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_274]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_274]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_281: G = __r_arr[0];
     let __v_282: G = __r_arr[1];
     let __v_283: G = __r_arr[2];
@@ -15376,7 +15521,7 @@ fn aiur_fn_124(
     if (__v_274 != __v_299) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_293]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_293]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_300: G = __r_arr[0];
     let __v_301: G = __r_arr[1];
     let __v_302: G = __r_arr[2];
@@ -15399,7 +15544,7 @@ fn aiur_fn_124(
     if (__v_293 != __v_318) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_312]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_312]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_319: G = __r_arr[0];
     let __v_320: G = __r_arr[1];
     let __v_321: G = __r_arr[2];
@@ -15422,7 +15567,7 @@ fn aiur_fn_124(
     if (__v_312 != __v_337) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_331]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_331]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_338: G = __r_arr[0];
     let __v_339: G = __r_arr[1];
     let __v_340: G = __r_arr[2];
@@ -15445,7 +15590,7 @@ fn aiur_fn_124(
     if (__v_331 != __v_356) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_350]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_350]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_357: G = __r_arr[0];
     let __v_358: G = __r_arr[1];
     let __v_359: G = __r_arr[2];
@@ -15468,7 +15613,7 @@ fn aiur_fn_124(
     if (__v_350 != __v_375) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_369]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_369]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_376: G = __r_arr[0];
     let __v_377: G = __r_arr[1];
     let __v_378: G = __r_arr[2];
@@ -15491,7 +15636,7 @@ fn aiur_fn_124(
     if (__v_369 != __v_394) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_388]; let __cu = true; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_388]; let __cu = true; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_395: G = __r_arr[0];
     let __v_396: G = __r_arr[1];
     let __v_397: G = __r_arr[2];
@@ -15513,51 +15658,53 @@ fn aiur_fn_124(
     if (__v_388 != __v_412) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) });
     }
-    let __ret: [G; OUT_124] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406];
-    if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_125] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406];
+    if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_125: usize = 2;
-const IN_125: usize = 2;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_126: usize = 2;
+const IN_126: usize = 2;
+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_125], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_4, __v_5]; 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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __ret: [G; OUT_125] = [__v_6];
-    if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_126] = [__v_6];
+    if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_126: usize = 4;
-const IN_126: usize = 4;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_127: usize = 4;
+const IN_127: usize = 4;
+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_126], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -15570,8 +15717,8 @@ fn aiur_fn_126(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_126] = [__v_2];
-        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_127] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -15585,19 +15732,19 @@ fn aiur_fn_126(
         let __v_21: G = G::from_u64(0);
         let __v_22: G = G::from_u64(1);
         let __v_23: G = G::from_u64(1);
-        let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_25, __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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_26]; 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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         let __v_28: G = G::from_u64(1);
         let __v_29: G = (__v_3 + __v_28);
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_1, __v_27, __v_29]; 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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-        let __ret: [G; OUT_126] = [__v_30];
-        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_127] = [__v_30];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15607,16 +15754,17 @@ fn aiur_fn_126(
   })
 }
 
-const INPUT_SIZE_127: usize = 18;
-const IN_127: usize = 18;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_128: usize = 18;
+const IN_128: usize = 18;
+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_127], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -15635,7 +15783,7 @@ fn aiur_fn_127(
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_18: G = __loaded[0];
     let __v_19: G = __loaded[1];
     let __v_20: G = __loaded[2];
@@ -15648,19 +15796,19 @@ fn aiur_fn_127(
     let __v_27: G = __loaded[9];
     match __v_18.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         match __v_28.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_127] = [__v_17];
-            if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_128] = [__v_17];
+            if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-            let __ret: [G; OUT_127] = [__v_29];
-            if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_128] = [__v_29];
+            if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -15669,7 +15817,7 @@ fn aiur_fn_127(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -15686,7 +15834,7 @@ fn aiur_fn_127(
         let __v_41: G = __r_arr[13];
         let __v_42: G = __r_arr[14];
         let __v_43: G = __r_arr[15];
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -15703,7 +15851,7 @@ fn aiur_fn_127(
         let __v_57: G = G::from_u64(0);
         let __v_58: G = G::from_u64(0);
         let __v_59: G = G::from_u64(0);
-        let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_13(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } } else { aiur_fn_13(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[14].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } };
         let __v_60: G = __r_arr[0];
         let __v_61: G = __r_arr[1];
         let __v_62: G = __r_arr[2];
@@ -15713,12 +15861,12 @@ fn aiur_fn_127(
         let __v_66: G = __r_arr[6];
         let __v_67: G = __r_arr[7];
         let __v_68: G = __r_arr[8];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __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 { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
-        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_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
-        let __ret: [G; OUT_127] = [__v_70];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_128] = [__v_70];
+        if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15728,22 +15876,23 @@ fn aiur_fn_127(
   })
 }
 
-const INPUT_SIZE_128: usize = 2;
-const IN_128: usize = 2;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+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_128], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_128] = [__v_0];
-        if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_129] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15756,33 +15905,34 @@ fn aiur_fn_128(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_1 - __v_12);
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11, __v_13]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_128] = [__v_14];
-        if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_129] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_129: usize = 1;
-const IN_129: usize = 1;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+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_129], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -15796,79 +15946,80 @@ fn aiur_fn_129(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_129] = [__v_12];
-        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_130] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_129] = [__v_12];
-        if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_130] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_130: usize = 2;
-const IN_130: usize = 2;
-const OUT_130: usize = 2;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+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_130], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_117] = { let __args: [G; IN_117] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_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_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     match __v_12.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_130] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_131] = [__v_5, __v_7];
+        if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_7]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_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_130] = [__v_5, __v_7];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_131] = [__v_5, __v_7];
+        if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15878,27 +16029,6 @@ fn aiur_fn_130(
   })
 }
 
-const INPUT_SIZE_131: usize = 2;
-const IN_131: usize = 2;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_131] = [__v_2];
-    if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_132: usize = 2;
 const IN_132: usize = 2;
 const OUT_132: usize = 1;
@@ -15909,13 +16039,14 @@ fn aiur_fn_132(
   unconstrained: bool,
 ) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_132] = [__v_3];
-    if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_132] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -15930,23 +16061,46 @@ fn aiur_fn_133(
   unconstrained: bool,
 ) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_133] = [__v_3];
+    if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+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_134], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_133] = [__v_0];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_134] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_3]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_133] = [__v_4];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_134] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -15956,19 +16110,20 @@ fn aiur_fn_133(
   })
 }
 
-const INPUT_SIZE_134: usize = 2;
-const IN_134: usize = 2;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -15983,10 +16138,10 @@ fn aiur_fn_134(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_15];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_135] = [__v_15];
+        if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -16001,32 +16156,32 @@ fn aiur_fn_134(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_15]; 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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_0]; 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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19, __v_20]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_134] = [__v_21];
-            if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_135] = [__v_21];
+            if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_21]; 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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_134] = [__v_23];
-            if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_135] = [__v_23];
+            if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -16041,16 +16196,17 @@ fn aiur_fn_134(
   })
 }
 
-const INPUT_SIZE_135: usize = 16;
-const IN_135: usize = 16;
-const OUT_135: usize = 8;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+const INPUT_SIZE_136: usize = 16;
+const IN_136: usize = 16;
+const OUT_136: usize = 8;
+fn aiur_fn_136(
+  inp: [G; IN_136],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
+) -> Result<[G; OUT_136], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -16075,22 +16231,23 @@ fn aiur_fn_135(
     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_135] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_136: usize = 16;
-const IN_136: usize = 16;
-const OUT_136: usize = 8;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_137: usize = 16;
+const IN_137: usize = 16;
+const OUT_137: usize = 8;
+fn aiur_fn_137(
+  inp: [G; IN_137],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_136], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -16115,22 +16272,23 @@ fn aiur_fn_136(
     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_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_137: usize = 16;
-const IN_137: usize = 16;
-const OUT_137: usize = 8;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_138: usize = 16;
+const IN_138: usize = 16;
+const OUT_138: usize = 8;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -16155,95 +16313,12 @@ fn aiur_fn_137(
     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_137] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_138] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_138: usize = 2;
-const IN_138: usize = 2;
-const OUT_138: usize = 1;
-fn aiur_fn_138(
-  inp: [G; IN_138],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_138], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_138] = [__v_14];
-        if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_12: G = __loaded[0];
-        let __v_13: G = __loaded[1];
-        let __v_14: G = __loaded[2];
-        let __v_15: G = __loaded[3];
-        let __v_16: G = __loaded[4];
-        let __v_17: G = __loaded[5];
-        let __v_18: G = __loaded[6];
-        let __v_19: G = __loaded[7];
-        let __v_20: G = __loaded[8];
-        let __v_21: G = __loaded[9];
-        match __v_12.as_canonical_u64() {
-          1u64 => {
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = G::from_u64(1);
-            let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_138] = [__v_24];
-            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          0u64 => {
-            let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-            let __v_23: G = __r_arr[0];
-            let __v_24: G = __r_arr[1];
-            let __v_25: G = __r_arr[2];
-            let __v_26: G = __r_arr[3];
-            let __v_27: G = __r_arr[4];
-            let __v_28: G = __r_arr[5];
-            let __v_29: G = __r_arr[6];
-            let __v_30: G = __r_arr[7];
-            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
-            let __v_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_138] = [__v_32];
-            if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
-    }
-  })
-}
-
 const INPUT_SIZE_139: usize = 2;
 const IN_139: usize = 2;
 const OUT_139: usize = 1;
@@ -16254,9 +16329,10 @@ fn aiur_fn_139(
   unconstrained: bool,
 ) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -16269,12 +16345,15 @@ fn aiur_fn_139(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_139] = [__v_1];
-        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_139] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -16287,13 +16366,16 @@ fn aiur_fn_139(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_139] = [__v_0];
-            if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_139] = [__v_24];
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
             let __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -16302,11 +16384,11 @@ fn aiur_fn_139(
             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_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_11, __v_21]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_139] = [__v_32];
-            if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -16331,9 +16413,10 @@ fn aiur_fn_140(
   unconstrained: bool,
 ) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -16347,11 +16430,11 @@ fn aiur_fn_140(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_140] = [__v_1];
-        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -16365,12 +16448,12 @@ fn aiur_fn_140(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_140] = [__v_0];
-            if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_137(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } } else { aiur_fn_137(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_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[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[1];
             let __v_25: G = __r_arr[2];
@@ -16379,11 +16462,11 @@ fn aiur_fn_140(
             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_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_11, __v_21]; 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 { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-            let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_140] = [__v_32];
-            if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -16408,6 +16491,85 @@ fn aiur_fn_141(
   unconstrained: bool,
 ) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_141] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_13: G = __loaded[1];
+        let __v_14: G = __loaded[2];
+        let __v_15: G = __loaded[3];
+        let __v_16: G = __loaded[4];
+        let __v_17: G = __loaded[5];
+        let __v_18: G = __loaded[6];
+        let __v_19: G = __loaded[7];
+        let __v_20: G = __loaded[8];
+        let __v_21: G = __loaded[9];
+        match __v_12.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_141] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_22: G = G::from_u64(0);
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } 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];
+            let __v_24: G = __r_arr[1];
+            let __v_25: G = __r_arr[2];
+            let __v_26: G = __r_arr[3];
+            let __v_27: G = __r_arr[4];
+            let __v_28: G = __r_arr[5];
+            let __v_29: G = __r_arr[6];
+            let __v_30: G = __r_arr[7];
+            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_11, __v_21]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_141] = [__v_32];
+            if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_142], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
@@ -16421,28 +16583,29 @@ fn aiur_fn_141(
     let __v_10: G = G::from_u64(0);
     let __v_11: G = G::from_u64(1);
     let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_15]; 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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_141] = [__v_16];
-    if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_142] = [__v_16];
+    if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_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_142], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
@@ -16456,28 +16619,29 @@ fn aiur_fn_142(
     let __v_10: G = G::from_u64(0);
     let __v_11: G = G::from_u64(1);
     let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14, __v_1]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_15]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-    let __ret: [G; OUT_142] = [__v_16];
-    if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_143] = [__v_16];
+    if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_143: usize = 0;
-const IN_143: usize = 0;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_144: usize = 0;
+const IN_144: usize = 0;
+const OUT_144: usize = 1;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_143], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(211);
     let __v_1: G = G::from_u64(151);
     let __v_2: G = G::from_u64(55);
@@ -16510,23 +16674,24 @@ fn aiur_fn_143(
     let __v_29: G = G::from_u64(70);
     let __v_30: G = G::from_u64(125);
     let __v_31: G = G::from_u64(182);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_143] = [__v_32];
-    if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_144] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_144: usize = 0;
-const IN_144: usize = 0;
-const OUT_144: usize = 1;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+const INPUT_SIZE_145: usize = 0;
+const IN_145: usize = 0;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_144], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(222);
     let __v_1: G = G::from_u64(245);
     let __v_2: G = G::from_u64(45);
@@ -16559,23 +16724,24 @@ fn aiur_fn_144(
     let __v_29: G = G::from_u64(186);
     let __v_30: G = G::from_u64(5);
     let __v_31: G = G::from_u64(110);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_144] = [__v_32];
-    if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_145] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_145: usize = 0;
-const IN_145: usize = 0;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_146: usize = 0;
+const IN_146: usize = 0;
+const OUT_146: usize = 1;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_145], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(145);
     let __v_1: G = G::from_u64(79);
     let __v_2: G = G::from_u64(156);
@@ -16608,23 +16774,24 @@ fn aiur_fn_145(
     let __v_29: G = G::from_u64(89);
     let __v_30: G = G::from_u64(76);
     let __v_31: G = G::from_u64(136);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_145] = [__v_32];
-    if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_146] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_146: usize = 0;
-const IN_146: usize = 0;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+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_146], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(9);
     let __v_1: G = G::from_u64(188);
     let __v_2: G = G::from_u64(37);
@@ -16657,23 +16824,24 @@ fn aiur_fn_146(
     let __v_29: G = G::from_u64(132);
     let __v_30: G = G::from_u64(211);
     let __v_31: G = G::from_u64(220);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_146] = [__v_32];
-    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_147] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_147], ExecError> {
+) -> Result<[G; OUT_148], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(38);
     let __v_1: G = G::from_u64(124);
     let __v_2: G = G::from_u64(10);
@@ -16706,23 +16874,24 @@ fn aiur_fn_147(
     let __v_29: G = G::from_u64(241);
     let __v_30: G = G::from_u64(73);
     let __v_31: G = G::from_u64(241);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_147] = [__v_32];
-    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_148] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_148], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(182);
     let __v_1: G = G::from_u64(187);
     let __v_2: G = G::from_u64(172);
@@ -16755,23 +16924,24 @@ fn aiur_fn_148(
     let __v_29: G = G::from_u64(159);
     let __v_30: G = G::from_u64(233);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_148] = [__v_32];
-    if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_149] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_149], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(188);
     let __v_1: G = G::from_u64(176);
     let __v_2: G = G::from_u64(155);
@@ -16804,23 +16974,24 @@ fn aiur_fn_149(
     let __v_29: G = G::from_u64(47);
     let __v_30: G = G::from_u64(211);
     let __v_31: G = G::from_u64(137);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_149] = [__v_32];
-    if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_150] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_150], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(116);
     let __v_1: G = G::from_u64(237);
     let __v_2: G = G::from_u64(31);
@@ -16853,23 +17024,24 @@ fn aiur_fn_150(
     let __v_29: G = G::from_u64(220);
     let __v_30: G = G::from_u64(190);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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];
-    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_151] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+const INPUT_SIZE_152: usize = 0;
+const IN_152: usize = 0;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
+) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(246);
     let __v_1: G = G::from_u64(28);
     let __v_2: G = G::from_u64(125);
@@ -16902,23 +17074,24 @@ fn aiur_fn_151(
     let __v_29: G = G::from_u64(227);
     let __v_30: G = G::from_u64(78);
     let __v_31: G = G::from_u64(189);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_151] = [__v_32];
-    if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_152] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_152: usize = 0;
-const IN_152: usize = 0;
-const OUT_152: usize = 1;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_153: usize = 0;
+const IN_153: usize = 0;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(172);
     let __v_1: G = G::from_u64(156);
     let __v_2: G = G::from_u64(114);
@@ -16951,23 +17124,24 @@ fn aiur_fn_152(
     let __v_29: G = G::from_u64(187);
     let __v_30: G = G::from_u64(192);
     let __v_31: G = G::from_u64(112);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_152] = [__v_32];
-    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_153] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_153: usize = 0;
-const IN_153: usize = 0;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+const INPUT_SIZE_154: usize = 0;
+const IN_154: usize = 0;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_153], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(159);
     let __v_1: G = G::from_u64(44);
     let __v_2: G = G::from_u64(164);
@@ -17000,23 +17174,24 @@ fn aiur_fn_153(
     let __v_29: G = G::from_u64(242);
     let __v_30: G = G::from_u64(15);
     let __v_31: G = G::from_u64(91);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_153] = [__v_32];
-    if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_154] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_154: usize = 0;
-const IN_154: usize = 0;
-const OUT_154: usize = 1;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_155: usize = 0;
+const IN_155: usize = 0;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(25);
     let __v_1: G = G::from_u64(125);
     let __v_2: G = G::from_u64(60);
@@ -17049,23 +17224,24 @@ fn aiur_fn_154(
     let __v_29: G = G::from_u64(47);
     let __v_30: G = G::from_u64(66);
     let __v_31: G = G::from_u64(113);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_154] = [__v_32];
-    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_155] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_155: usize = 0;
-const IN_155: usize = 0;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_156: usize = 0;
+const IN_156: usize = 0;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_155], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(7);
     let __v_1: G = G::from_u64(19);
     let __v_2: G = G::from_u64(64);
@@ -17098,23 +17274,24 @@ fn aiur_fn_155(
     let __v_29: G = G::from_u64(87);
     let __v_30: G = G::from_u64(127);
     let __v_31: G = G::from_u64(87);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_155] = [__v_32];
-    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_156] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_156: usize = 0;
-const IN_156: usize = 0;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_157: usize = 0;
+const IN_157: usize = 0;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_156], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(131);
     let __v_1: G = G::from_u64(227);
     let __v_2: G = G::from_u64(206);
@@ -17147,23 +17324,24 @@ fn aiur_fn_156(
     let __v_29: G = G::from_u64(173);
     let __v_30: G = G::from_u64(124);
     let __v_31: G = G::from_u64(164);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_156] = [__v_32];
-    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_157] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_157: usize = 0;
-const IN_157: usize = 0;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+const INPUT_SIZE_158: usize = 0;
+const IN_158: usize = 0;
+const OUT_158: usize = 1;
+fn aiur_fn_158(
+  inp: [G; IN_158],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
+) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(135);
     let __v_1: G = G::from_u64(91);
     let __v_2: G = G::from_u64(232);
@@ -17196,23 +17374,24 @@ fn aiur_fn_157(
     let __v_29: G = G::from_u64(232);
     let __v_30: G = G::from_u64(76);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_157] = [__v_32];
-    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_158] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_158: usize = 0;
-const IN_158: usize = 0;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_159: usize = 0;
+const IN_159: usize = 0;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], ExecError> {
+) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(225);
     let __v_1: G = G::from_u64(238);
     let __v_2: G = G::from_u64(76);
@@ -17245,23 +17424,24 @@ fn aiur_fn_158(
     let __v_29: G = G::from_u64(74);
     let __v_30: G = G::from_u64(147);
     let __v_31: G = G::from_u64(229);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_158] = [__v_32];
-    if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_159] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_159: usize = 0;
-const IN_159: usize = 0;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_160: usize = 0;
+const IN_160: usize = 0;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_159], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(191);
     let __v_1: G = G::from_u64(5);
     let __v_2: G = G::from_u64(142);
@@ -17294,23 +17474,24 @@ fn aiur_fn_159(
     let __v_29: G = G::from_u64(38);
     let __v_30: G = G::from_u64(125);
     let __v_31: G = G::from_u64(87);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_159] = [__v_32];
-    if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_160] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_160: usize = 0;
-const IN_160: usize = 0;
-const OUT_160: usize = 1;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_161: usize = 0;
+const IN_161: usize = 0;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(194);
     let __v_1: G = G::from_u64(254);
     let __v_2: G = G::from_u64(94);
@@ -17343,23 +17524,24 @@ fn aiur_fn_160(
     let __v_29: G = G::from_u64(154);
     let __v_30: G = G::from_u64(75);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_160] = [__v_32];
-    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_161] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_161: usize = 0;
-const IN_161: usize = 0;
-const OUT_161: usize = 1;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_162: usize = 0;
+const IN_162: usize = 0;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(10);
     let __v_1: G = G::from_u64(236);
     let __v_2: G = G::from_u64(146);
@@ -17392,23 +17574,24 @@ fn aiur_fn_161(
     let __v_29: G = G::from_u64(185);
     let __v_30: G = G::from_u64(84);
     let __v_31: G = G::from_u64(128);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_161] = [__v_32];
-    if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_162] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_162: usize = 0;
-const IN_162: usize = 0;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_163: usize = 0;
+const IN_163: usize = 0;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(89);
     let __v_1: G = G::from_u64(228);
     let __v_2: G = G::from_u64(125);
@@ -17441,23 +17624,24 @@ fn aiur_fn_162(
     let __v_29: G = G::from_u64(61);
     let __v_30: G = G::from_u64(206);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_162] = [__v_32];
-    if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_163] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_163: usize = 0;
-const IN_163: usize = 0;
-const OUT_163: usize = 1;
-fn aiur_fn_163(
-  inp: [G; IN_163],
+const INPUT_SIZE_164: usize = 0;
+const IN_164: usize = 0;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_163], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(44);
     let __v_1: G = G::from_u64(157);
     let __v_2: G = G::from_u64(45);
@@ -17490,23 +17674,24 @@ fn aiur_fn_163(
     let __v_29: G = G::from_u64(154);
     let __v_30: G = G::from_u64(171);
     let __v_31: G = G::from_u64(207);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_163] = [__v_32];
-    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_164] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_164: usize = 0;
-const IN_164: usize = 0;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
+const INPUT_SIZE_165: usize = 0;
+const IN_165: usize = 0;
+const OUT_165: usize = 1;
+fn aiur_fn_165(
+  inp: [G; IN_165],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(47);
     let __v_1: G = G::from_u64(18);
     let __v_2: G = G::from_u64(243);
@@ -17539,23 +17724,24 @@ fn aiur_fn_164(
     let __v_29: G = G::from_u64(171);
     let __v_30: G = G::from_u64(113);
     let __v_31: G = G::from_u64(49);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_164] = [__v_32];
-    if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_165] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_165: usize = 0;
-const IN_165: usize = 0;
-const OUT_165: usize = 1;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_166: usize = 0;
+const IN_166: usize = 0;
+const OUT_166: usize = 1;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(131);
     let __v_1: G = G::from_u64(60);
     let __v_2: G = G::from_u64(91);
@@ -17588,23 +17774,24 @@ fn aiur_fn_165(
     let __v_29: G = G::from_u64(99);
     let __v_30: G = G::from_u64(14);
     let __v_31: G = G::from_u64(52);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_165] = [__v_32];
-    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_166] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_166: usize = 0;
-const IN_166: usize = 0;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_167: usize = 0;
+const IN_167: usize = 0;
+const OUT_167: usize = 1;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], ExecError> {
+) -> Result<[G; OUT_167], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(114);
     let __v_1: G = G::from_u64(50);
     let __v_2: G = G::from_u64(9);
@@ -17637,23 +17824,24 @@ fn aiur_fn_166(
     let __v_29: G = G::from_u64(175);
     let __v_30: G = G::from_u64(171);
     let __v_31: G = G::from_u64(154);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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];
-    if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_167] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[167].weight(); } record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_167: usize = 0;
-const IN_167: usize = 0;
-const OUT_167: usize = 1;
-fn aiur_fn_167(
-  inp: [G; IN_167],
+const INPUT_SIZE_168: usize = 0;
+const IN_168: usize = 0;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_167], ExecError> {
+) -> Result<[G; OUT_168], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(195);
     let __v_1: G = G::from_u64(176);
     let __v_2: G = G::from_u64(11);
@@ -17686,23 +17874,24 @@ fn aiur_fn_167(
     let __v_29: G = G::from_u64(58);
     let __v_30: G = G::from_u64(4);
     let __v_31: G = G::from_u64(240);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_167] = [__v_32];
-    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_168] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 0;
-const IN_168: usize = 0;
-const OUT_168: usize = 1;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_169: usize = 0;
+const IN_169: usize = 0;
+const OUT_169: usize = 1;
+fn aiur_fn_169(
+  inp: [G; IN_169],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(110);
     let __v_1: G = G::from_u64(112);
     let __v_2: G = G::from_u64(205);
@@ -17735,23 +17924,24 @@ fn aiur_fn_168(
     let __v_29: G = G::from_u64(255);
     let __v_30: G = G::from_u64(9);
     let __v_31: G = G::from_u64(120);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_168] = [__v_32];
-    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_169] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_169: usize = 0;
-const IN_169: usize = 0;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
+const INPUT_SIZE_170: usize = 0;
+const IN_170: usize = 0;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_169], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(216);
     let __v_1: G = G::from_u64(221);
     let __v_2: G = G::from_u64(236);
@@ -17784,23 +17974,24 @@ fn aiur_fn_169(
     let __v_29: G = G::from_u64(52);
     let __v_30: G = G::from_u64(249);
     let __v_31: G = G::from_u64(243);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_169] = [__v_32];
-    if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_170] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_170: usize = 0;
-const IN_170: usize = 0;
-const OUT_170: usize = 1;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_171: usize = 0;
+const IN_171: usize = 0;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], ExecError> {
+) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(202);
     let __v_1: G = G::from_u64(48);
     let __v_2: G = G::from_u64(34);
@@ -17833,23 +18024,24 @@ fn aiur_fn_170(
     let __v_29: G = G::from_u64(17);
     let __v_30: G = G::from_u64(32);
     let __v_31: G = G::from_u64(112);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_170] = [__v_32];
-    if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_171] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_171: usize = 0;
-const IN_171: usize = 0;
-const OUT_171: usize = 1;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_172: usize = 0;
+const IN_172: usize = 0;
+const OUT_172: usize = 1;
+fn aiur_fn_172(
+  inp: [G; IN_172],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(202);
     let __v_1: G = G::from_u64(75);
     let __v_2: G = G::from_u64(57);
@@ -17882,23 +18074,24 @@ fn aiur_fn_171(
     let __v_29: G = G::from_u64(27);
     let __v_30: G = G::from_u64(28);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_171] = [__v_32];
-    if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_172] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[172].weight(); } record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_172: usize = 0;
-const IN_172: usize = 0;
-const OUT_172: usize = 1;
-fn aiur_fn_172(
-  inp: [G; IN_172],
+const INPUT_SIZE_173: usize = 0;
+const IN_173: usize = 0;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(162);
     let __v_1: G = G::from_u64(154);
     let __v_2: G = G::from_u64(99);
@@ -17931,23 +18124,24 @@ fn aiur_fn_172(
     let __v_29: G = G::from_u64(240);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(98);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_172] = [__v_32];
-    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_173] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_173: usize = 0;
-const IN_173: usize = 0;
-const OUT_173: usize = 1;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_174: usize = 0;
+const IN_174: usize = 0;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(221);
     let __v_1: G = G::from_u64(161);
     let __v_2: G = G::from_u64(43);
@@ -17980,23 +18174,24 @@ fn aiur_fn_173(
     let __v_29: G = G::from_u64(244);
     let __v_30: G = G::from_u64(198);
     let __v_31: G = G::from_u64(62);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_173] = [__v_32];
-    if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_174] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_174: usize = 0;
-const IN_174: usize = 0;
-const OUT_174: usize = 1;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_175: usize = 0;
+const IN_175: usize = 0;
+const OUT_175: usize = 1;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(169);
     let __v_1: G = G::from_u64(22);
     let __v_2: G = G::from_u64(36);
@@ -18029,23 +18224,24 @@ fn aiur_fn_174(
     let __v_29: G = G::from_u64(188);
     let __v_30: G = G::from_u64(250);
     let __v_31: G = G::from_u64(236);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_174] = [__v_32];
-    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_175] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_175: usize = 0;
-const IN_175: usize = 0;
-const OUT_175: usize = 1;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_176: usize = 0;
+const IN_176: usize = 0;
+const OUT_176: usize = 1;
+fn aiur_fn_176(
+  inp: [G; IN_176],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], ExecError> {
+) -> Result<[G; OUT_176], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(123);
     let __v_1: G = G::from_u64(216);
     let __v_2: G = G::from_u64(225);
@@ -18078,23 +18274,24 @@ fn aiur_fn_175(
     let __v_29: G = G::from_u64(127);
     let __v_30: G = G::from_u64(64);
     let __v_31: G = G::from_u64(18);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_175] = [__v_32];
-    if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_176] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_176: usize = 0;
-const IN_176: usize = 0;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+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_176], ExecError> {
+) -> Result<[G; OUT_177], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(28);
     let __v_1: G = G::from_u64(23);
     let __v_2: G = G::from_u64(0);
@@ -18127,23 +18324,24 @@ fn aiur_fn_176(
     let __v_29: G = G::from_u64(169);
     let __v_30: G = G::from_u64(250);
     let __v_31: G = G::from_u64(120);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_176] = [__v_32];
-    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_177] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_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_177], ExecError> {
+) -> Result<[G; OUT_178], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(22);
     let __v_1: G = G::from_u64(133);
     let __v_2: G = G::from_u64(48);
@@ -18176,23 +18374,24 @@ fn aiur_fn_177(
     let __v_29: G = G::from_u64(40);
     let __v_30: G = G::from_u64(229);
     let __v_31: G = G::from_u64(96);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_177] = [__v_32];
-    if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_178] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_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_178], ExecError> {
+) -> Result<[G; OUT_179], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(12);
     let __v_1: G = G::from_u64(112);
     let __v_2: G = G::from_u64(114);
@@ -18225,23 +18424,24 @@ fn aiur_fn_178(
     let __v_29: G = G::from_u64(227);
     let __v_30: G = G::from_u64(108);
     let __v_31: G = G::from_u64(113);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_178] = [__v_32];
-    if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_179] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_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_179], ExecError> {
+) -> Result<[G; OUT_180], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(102);
     let __v_1: G = G::from_u64(242);
     let __v_2: G = G::from_u64(155);
@@ -18274,87 +18474,88 @@ fn aiur_fn_179(
     let __v_29: G = G::from_u64(176);
     let __v_30: G = G::from_u64(189);
     let __v_31: G = G::from_u64(213);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_179] = [__v_32];
-    if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_180] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_180: usize = 1;
-const IN_180: usize = 1;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_181: usize = 1;
+const IN_181: usize = 1;
+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_180], ExecError> {
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[175].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_180] = [__v_3];
-        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_181] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_180] = [__v_5];
-            if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_181] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_180] = [__v_7];
-                if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_181] = [__v_7];
+                if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[178].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_180] = [__v_9];
-                    if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_181] = [__v_9];
+                    if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_180] = [__v_11];
-                        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_181] = [__v_11];
+                        if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_11: G = G::from_u64(0);
-                        let __ret: [G; OUT_180] = [__v_11];
-                        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_181] = [__v_11];
+                        if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -18369,16 +18570,17 @@ fn aiur_fn_180(
   })
 }
 
-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_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_181], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(64);
     let __v_2: G = G::from_u64(0);
@@ -18390,28 +18592,29 @@ fn aiur_fn_181(
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_13: G = G::from_u64(7);
     let __v_14: G = G::from_u64(0);
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_181] = [__v_16];
-    if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_182] = [__v_16];
+    if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_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_182], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(0);
@@ -18423,80 +18626,81 @@ fn aiur_fn_182(
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_13: G = G::from_u64(7);
     let __v_14: G = G::from_u64(0);
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_182] = [__v_16];
-    if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_183] = [__v_16];
+    if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_183: usize = 3;
-const IN_183: usize = 3;
-const OUT_183: usize = 2;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_184: usize = 3;
+const IN_184: usize = 3;
+const OUT_184: usize = 2;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[175].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_183] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_184] = [__v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[183].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_183] = [__v_7, __v_8];
-            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_184] = [__v_7, __v_8];
+            if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_184] = { let __args: [G; IN_184] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_1]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_183] = [__v_9, __v_10];
-                if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_184] = [__v_9, __v_10];
+                if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[178].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_13: G = (__v_10 + __v_12);
                 match __v_13.as_canonical_u64() {
@@ -18505,13 +18709,13 @@ fn aiur_fn_183(
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
-                    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_183] = [__v_14, __v_18];
-                    if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_184] = [__v_14, __v_18];
+                    if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -18521,32 +18725,32 @@ fn aiur_fn_183(
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(0);
-                        let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_183] = [__v_17, __v_21];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_184] = [__v_17, __v_21];
+                        if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_17]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_18, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_183] = [__v_20, __v_21];
-                            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_184] = [__v_20, __v_21];
+                            if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_19]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_183] = [__v_20, __v_21];
-                            if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_184] = [__v_20, __v_21];
+                            if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -18563,18 +18767,19 @@ fn aiur_fn_183(
   })
 }
 
-const INPUT_SIZE_184: usize = 1;
-const IN_184: usize = 1;
-const OUT_184: usize = 2;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_185: usize = 1;
+const IN_185: usize = 1;
+const OUT_185: usize = 2;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -18584,36 +18789,36 @@ fn aiur_fn_184(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_184] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_185] = [__v_4, __v_8];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[180].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                let __ret: [G; OUT_184] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_185] = [__v_14, __v_15];
+                if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -18621,9 +18826,9 @@ fn aiur_fn_184(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_184] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_185] = [__v_14, __v_18];
+                if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -18633,9 +18838,9 @@ fn aiur_fn_184(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_184] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_185] = [__v_12, __v_16];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -18644,31 +18849,32 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 1;
-const IN_185: usize = 1;
-const OUT_185: usize = 2;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_186: usize = 1;
+const IN_186: usize = 1;
+const OUT_186: usize = 2;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_9: G = (__v_6 + __v_8);
         match __v_9.as_canonical_u64() {
@@ -18677,15 +18883,15 @@ fn aiur_fn_185(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_185] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_186] = [__v_10, __v_14];
+            if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_185] = [__v_10, __v_0];
-            if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_186] = [__v_10, __v_0];
+            if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -18695,27 +18901,28 @@ fn aiur_fn_185(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_185] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_186] = [__v_5, __v_9];
+        if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_186: usize = 1;
-const IN_186: usize = 1;
-const OUT_186: usize = 2;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_187: usize = 1;
+const IN_187: usize = 1;
+const OUT_187: usize = 2;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -18725,8 +18932,8 @@ fn aiur_fn_186(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_186] = [__v_5, __v_0];
-            if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_187] = [__v_5, __v_0];
+            if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -18734,9 +18941,9 @@ fn aiur_fn_186(
             let __v_6: G = G::from_u64(0);
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_186] = [__v_5, __v_9];
-            if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_187] = [__v_5, __v_9];
+            if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -18746,25 +18953,26 @@ fn aiur_fn_186(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_187] = [__v_5, __v_9];
+        if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_187: usize = 0;
-const IN_187: usize = 0;
-const OUT_187: usize = 1;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+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_187], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(227);
     let __v_1: G = G::from_u64(42);
     let __v_2: G = G::from_u64(180);
@@ -18797,23 +19005,24 @@ fn aiur_fn_187(
     let __v_29: G = G::from_u64(82);
     let __v_30: G = G::from_u64(3);
     let __v_31: G = G::from_u64(116);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_187] = [__v_32];
-    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_188] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_188: usize = 0;
-const IN_188: usize = 0;
-const OUT_188: usize = 1;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_189: usize = 0;
+const IN_189: usize = 0;
+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_188], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(59);
     let __v_1: G = G::from_u64(51);
     let __v_2: G = G::from_u64(76);
@@ -18846,23 +19055,24 @@ fn aiur_fn_188(
     let __v_29: G = G::from_u64(189);
     let __v_30: G = G::from_u64(191);
     let __v_31: G = G::from_u64(110);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_188] = [__v_32];
-    if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_189] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_189: usize = 0;
-const IN_189: usize = 0;
-const OUT_189: usize = 1;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+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_189], ExecError> {
+) -> Result<[G; OUT_190], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(103);
     let __v_1: G = G::from_u64(244);
     let __v_2: G = G::from_u64(116);
@@ -18895,23 +19105,24 @@ fn aiur_fn_189(
     let __v_29: G = G::from_u64(135);
     let __v_30: G = G::from_u64(43);
     let __v_31: G = G::from_u64(164);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_189] = [__v_32];
-    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_190] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_190: usize = 0;
-const IN_190: usize = 0;
-const OUT_190: usize = 1;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+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_190], ExecError> {
+) -> Result<[G; OUT_191], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(79);
     let __v_1: G = G::from_u64(157);
     let __v_2: G = G::from_u64(78);
@@ -18944,23 +19155,24 @@ fn aiur_fn_190(
     let __v_29: G = G::from_u64(144);
     let __v_30: G = G::from_u64(87);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_190] = [__v_32];
-    if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_191] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[191].weight(); } record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_192: usize = 0;
+const IN_192: usize = 0;
+const OUT_192: usize = 1;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(197);
     let __v_1: G = G::from_u64(247);
     let __v_2: G = G::from_u64(177);
@@ -18993,23 +19205,24 @@ fn aiur_fn_191(
     let __v_29: G = G::from_u64(115);
     let __v_30: G = G::from_u64(55);
     let __v_31: G = G::from_u64(35);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_191] = [__v_32];
-    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_192] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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_193: usize = 0;
+const IN_193: usize = 0;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(202);
     let __v_1: G = G::from_u64(202);
     let __v_2: G = G::from_u64(234);
@@ -19042,63 +19255,64 @@ fn aiur_fn_192(
     let __v_29: G = G::from_u64(61);
     let __v_30: G = G::from_u64(51);
     let __v_31: G = G::from_u64(18);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_192] = [__v_32];
-    if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_193] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_193: usize = 1;
-const IN_193: usize = 1;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_194: usize = 1;
+const IN_194: usize = 1;
+const OUT_194: usize = 1;
+fn aiur_fn_194(
+  inp: [G; IN_194],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_194], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_193] = [__v_3];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_194] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[191].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_193] = [__v_5];
-            if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_194] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_193] = [__v_7];
-                if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_194] = [__v_7];
+                if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_193] = [__v_7];
-                if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_194] = [__v_7];
+                if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -19109,61 +19323,63 @@ fn aiur_fn_193(
   })
 }
 
-const INPUT_SIZE_194: usize = 1;
-const IN_194: usize = 1;
-const OUT_194: usize = 1;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_195: usize = 1;
+const IN_195: usize = 1;
+const OUT_195: usize = 1;
+fn aiur_fn_195(
+  inp: [G; IN_195],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_195], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_194] = [__v_7];
-        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_195] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(2);
-        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_194] = [__v_7];
-        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_195] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_195: usize = 2;
-const IN_195: usize = 2;
-const OUT_195: usize = 2;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_196: usize = 2;
+const IN_196: usize = 2;
+const OUT_196: usize = 2;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_1]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -19172,13 +19388,13 @@ fn aiur_fn_195(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_195] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_196] = [__v_5, __v_8];
+        if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_4]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         match __v_5.as_canonical_u64() {
@@ -19186,13 +19402,13 @@ fn aiur_fn_195(
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_195] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_196] = [__v_7, __v_10];
+            if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             match __v_7.as_canonical_u64() {
@@ -19200,9 +19416,9 @@ fn aiur_fn_195(
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = G::from_u64(1);
-                let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_195] = [__v_9, __v_12];
-                if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_196] = [__v_9, __v_12];
+                if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
@@ -19217,17 +19433,17 @@ fn aiur_fn_195(
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(1);
                 let __v_19: G = G::from_u64(1);
-                let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_21, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+                let __v_20: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_21, __v_8]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
                 let __v_23: G = G::from_u64(1);
-                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6, __v_22]; 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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                let __ret: [G; OUT_195] = [__v_23, __v_25];
-                if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_196] = [__v_23, __v_25];
+                if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19247,18 +19463,19 @@ fn aiur_fn_195(
   })
 }
 
-const INPUT_SIZE_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 2;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_197: usize = 1;
+const IN_197: usize = 1;
+const OUT_197: usize = 2;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -19268,22 +19485,22 @@ fn aiur_fn_196(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_196] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_197] = [__v_4, __v_8];
+        if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_6]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(2);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_8]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_7]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         match __v_10.as_canonical_u64() {
@@ -19292,13 +19509,13 @@ fn aiur_fn_196(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_196] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_197] = [__v_12, __v_16];
+            if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_9]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -19307,21 +19524,21 @@ fn aiur_fn_196(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_196] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_197] = [__v_14, __v_18];
+                if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_11]; 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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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 __v_16: G = (__v_14 - __v_15);
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_16]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                let __ret: [G; OUT_196] = [__v_17, __v_18];
-                if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_197] = [__v_17, __v_18];
+                if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19338,18 +19555,19 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 1;
-const IN_197: usize = 1;
-const OUT_197: usize = 2;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_198: usize = 1;
+const IN_198: usize = 1;
+const OUT_198: usize = 2;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -19359,28 +19577,28 @@ fn aiur_fn_197(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_198] = [__v_4, __v_8];
+        if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
               0u64 => {
@@ -19388,13 +19606,13 @@ fn aiur_fn_197(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_197] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_198] = [__v_14, __v_18];
+                if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -19404,28 +19622,28 @@ fn aiur_fn_197(
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(0);
-                    let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_197] = [__v_17, __v_21];
-                    if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_198] = [__v_17, __v_21];
+                    if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_17: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_17]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_18]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
                     let __v_20: G = __r_arr[1];
-                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                     let __v_21: G = __loaded[0];
                     let __v_22: G = __loaded[1];
                     let __v_23: G = __loaded[2];
                     let __v_24: G = __loaded[3];
                     match __v_21.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[190].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
                           0u64 => {
@@ -19433,13 +19651,13 @@ fn aiur_fn_197(
                             let __v_28: G = G::from_u64(0);
                             let __v_29: G = G::from_u64(0);
                             let __v_30: G = G::from_u64(0);
-                            let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_197] = [__v_27, __v_31];
-                            if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __ret: [G; OUT_198] = [__v_27, __v_31];
+                            if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_20]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -19449,35 +19667,35 @@ fn aiur_fn_197(
                                 let __v_31: G = G::from_u64(0);
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(0);
-                                let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_197] = [__v_30, __v_34];
-                                if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __ret: [G; OUT_198] = [__v_30, __v_34];
+                                if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_30: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_20, __v_30]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_31: G = __r_arr[0];
                                 let __v_32: G = G::from_u64(2);
-                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_32]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_33: G = __r_arr[0];
                                 let __v_34: G = G::from_u64(3);
-                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_34]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_35: G = __r_arr[0];
                                 let __v_36: G = G::from_u64(0);
                                 let __v_37: G = G::from_u64(0);
                                 let __v_38: G = G::from_u64(0);
                                 let __v_39: G = G::from_u64(1);
                                 let __v_40: G = G::from_u64(1);
-                                let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+                                let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_44]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                                 let __v_46: G = __r_arr[1];
-                                let __ret: [G; OUT_197] = [__v_45, __v_46];
-                                if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_198] = [__v_45, __v_46];
+                                if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -19489,9 +19707,9 @@ fn aiur_fn_197(
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(0);
                         let __v_28: G = G::from_u64(0);
-                        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_197] = [__v_25, __v_29];
-                        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_198] = [__v_25, __v_29];
+                        if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -19505,9 +19723,9 @@ fn aiur_fn_197(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_197] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_198] = [__v_12, __v_16];
+            if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -19516,34 +19734,35 @@ fn aiur_fn_197(
   })
 }
 
-const INPUT_SIZE_198: usize = 1;
-const IN_198: usize = 1;
-const OUT_198: usize = 3;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_199: usize = 1;
+const IN_199: usize = 1;
+const OUT_199: usize = 3;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = []; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(2);
             let __v_11: G = (__v_9 - __v_10);
@@ -19551,13 +19770,13 @@ fn aiur_fn_198(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_13]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_15]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_198] = [__v_12, __v_14, __v_16];
-                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_199] = [__v_12, __v_14, __v_16];
+                if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19565,13 +19784,13 @@ fn aiur_fn_198(
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
-                let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
-                let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_198] = [__v_12, __v_16, __v_20];
-                if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_199] = [__v_12, __v_16, __v_20];
+                if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -19581,13 +19800,13 @@ fn aiur_fn_198(
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_198] = [__v_9, __v_13, __v_17];
-            if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_199] = [__v_9, __v_13, __v_17];
+            if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -19597,39 +19816,40 @@ fn aiur_fn_198(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_7, __v_11, __v_15];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_199] = [__v_7, __v_11, __v_15];
+        if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_199: usize = 3;
-const IN_199: usize = 3;
-const OUT_199: usize = 2;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_200: usize = 3;
+const IN_200: usize = 3;
+const OUT_200: usize = 2;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_199], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -19639,21 +19859,21 @@ fn aiur_fn_199(
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_199] = [__v_8, __v_12];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_200] = [__v_8, __v_12];
+            if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_1, __v_2]; 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 { let __r = record.function_queries[386].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_9]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(1);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_11]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_10, __v_12]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             match __v_13.as_canonical_u64() {
@@ -19662,17 +19882,17 @@ fn aiur_fn_199(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_199] = [__v_15, __v_19];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_200] = [__v_15, __v_19];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_14]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                let __ret: [G; OUT_199] = [__v_15, __v_16];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_200] = [__v_15, __v_16];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19683,33 +19903,33 @@ fn aiur_fn_199(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[191].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_200] = { let __args: [G; IN_200] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_2]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_7]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_199] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_200] = [__v_8, __v_9];
+            if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_197] = { let __args: [G; IN_197] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_1]; 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 { let __r = record.function_queries[198].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_199] = [__v_9, __v_10];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_200] = [__v_9, __v_10];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19717,9 +19937,9 @@ fn aiur_fn_199(
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_199] = [__v_9, __v_13];
-                if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_200] = [__v_9, __v_13];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -19730,65 +19950,66 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 2;
-const IN_200: usize = 2;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+const OUT_201: usize = 1;
+fn aiur_fn_201(
+  inp: [G; IN_201],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_200], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_200] = [__v_2];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_201] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_200] = [__v_2];
-            if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_201] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_200] = [__v_2];
-                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_201] = [__v_2];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __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 { let __r = record.function_queries[202].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __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 { let __r = record.function_queries[202].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_200] = [__v_19];
-                if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_201] = [__v_19];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -19808,41 +20029,43 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 2;
-const IN_201: usize = 2;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_202: usize = 2;
+const IN_202: usize = 2;
+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_201], ExecError> {
+) -> Result<[G; OUT_202], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_3, __v_1]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __ret: [G; OUT_201] = [__v_5];
-    if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_202] = [__v_5];
+    if !unconstrained { record.virt += record.function_queries[202].weight(); } record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_202: usize = 0;
-const IN_202: usize = 0;
-const OUT_202: usize = 1;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_203: usize = 0;
+const IN_203: usize = 0;
+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_202], ExecError> {
+) -> Result<[G; OUT_203], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(81);
     let __v_1: G = G::from_u64(134);
     let __v_2: G = G::from_u64(217);
@@ -19875,23 +20098,24 @@ fn aiur_fn_202(
     let __v_29: G = G::from_u64(158);
     let __v_30: G = G::from_u64(90);
     let __v_31: G = G::from_u64(110);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_202] = [__v_32];
-    if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_203] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_203: usize = 0;
-const IN_203: usize = 0;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_204: usize = 0;
+const IN_204: usize = 0;
+const OUT_204: usize = 1;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(255);
     let __v_1: G = G::from_u64(69);
     let __v_2: G = G::from_u64(149);
@@ -19924,23 +20148,24 @@ fn aiur_fn_203(
     let __v_29: G = G::from_u64(29);
     let __v_30: G = G::from_u64(3);
     let __v_31: G = G::from_u64(158);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_203] = [__v_32];
-    if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_204] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_204: usize = 0;
-const IN_204: usize = 0;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_205: usize = 0;
+const IN_205: usize = 0;
+const OUT_205: usize = 1;
+fn aiur_fn_205(
+  inp: [G; IN_205],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_204], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(15);
     let __v_1: G = G::from_u64(2);
     let __v_2: G = G::from_u64(80);
@@ -19973,23 +20198,24 @@ fn aiur_fn_204(
     let __v_29: G = G::from_u64(129);
     let __v_30: G = G::from_u64(40);
     let __v_31: G = G::from_u64(217);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_204] = [__v_32];
-    if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_205] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_205: usize = 0;
-const IN_205: usize = 0;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+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_205], ExecError> {
+) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(9);
     let __v_1: G = G::from_u64(238);
     let __v_2: G = G::from_u64(180);
@@ -20022,23 +20248,24 @@ fn aiur_fn_205(
     let __v_29: G = G::from_u64(203);
     let __v_30: G = G::from_u64(141);
     let __v_31: G = G::from_u64(52);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_205] = [__v_32];
-    if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_206] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_206], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(37);
     let __v_1: G = G::from_u64(138);
     let __v_2: G = G::from_u64(115);
@@ -20071,23 +20298,24 @@ fn aiur_fn_206(
     let __v_29: G = G::from_u64(239);
     let __v_30: G = G::from_u64(202);
     let __v_31: G = G::from_u64(62);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_206] = [__v_32];
-    if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_207] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[207].weight(); } record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_207], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(119);
     let __v_1: G = G::from_u64(213);
     let __v_2: G = G::from_u64(25);
@@ -20120,23 +20348,24 @@ fn aiur_fn_207(
     let __v_29: G = G::from_u64(53);
     let __v_30: G = G::from_u64(2);
     let __v_31: G = G::from_u64(160);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_207] = [__v_32];
-    if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_208] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[208].weight(); } record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_208], ExecError> {
+) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(32);
     let __v_1: G = G::from_u64(59);
     let __v_2: G = G::from_u64(118);
@@ -20169,23 +20398,24 @@ fn aiur_fn_208(
     let __v_29: G = G::from_u64(250);
     let __v_30: G = G::from_u64(110);
     let __v_31: G = G::from_u64(238);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_208] = [__v_32];
-    if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_209] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[209].weight(); } record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+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_209], ExecError> {
+) -> Result<[G; OUT_210], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(84);
     let __v_1: G = G::from_u64(139);
     let __v_2: G = G::from_u64(191);
@@ -20218,23 +20448,24 @@ fn aiur_fn_209(
     let __v_29: G = G::from_u64(210);
     let __v_30: G = G::from_u64(29);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_209] = [__v_32];
-    if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_210] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[210].weight(); } record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     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],
+const INPUT_SIZE_211: usize = 0;
+const IN_211: usize = 0;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_210], ExecError> {
+) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(239);
     let __v_1: G = G::from_u64(78);
     let __v_2: G = G::from_u64(116);
@@ -20267,23 +20498,24 @@ fn aiur_fn_210(
     let __v_29: G = G::from_u64(206);
     let __v_30: G = G::from_u64(253);
     let __v_31: G = G::from_u64(201);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_210] = [__v_32];
-    if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_211] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[211].weight(); } record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_211: usize = 0;
-const IN_211: usize = 0;
-const OUT_211: usize = 1;
-fn aiur_fn_211(
-  inp: [G; IN_211],
+const INPUT_SIZE_212: usize = 0;
+const IN_212: usize = 0;
+const OUT_212: usize = 1;
+fn aiur_fn_212(
+  inp: [G; IN_212],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_211], ExecError> {
+) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(135);
     let __v_1: G = G::from_u64(9);
     let __v_2: G = G::from_u64(245);
@@ -20316,23 +20548,24 @@ fn aiur_fn_211(
     let __v_29: G = G::from_u64(74);
     let __v_30: G = G::from_u64(12);
     let __v_31: G = G::from_u64(41);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_211] = [__v_32];
-    if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_212] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_212: usize = 0;
-const IN_212: usize = 0;
-const OUT_212: usize = 1;
-fn aiur_fn_212(
-  inp: [G; IN_212],
+const INPUT_SIZE_213: usize = 0;
+const IN_213: usize = 0;
+const OUT_213: usize = 1;
+fn aiur_fn_213(
+  inp: [G; IN_213],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_212], ExecError> {
+) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(13);
     let __v_1: G = G::from_u64(35);
     let __v_2: G = G::from_u64(99);
@@ -20365,23 +20598,24 @@ fn aiur_fn_212(
     let __v_29: G = G::from_u64(221);
     let __v_30: G = G::from_u64(226);
     let __v_31: G = G::from_u64(34);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_212] = [__v_32];
-    if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_213] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_213: usize = 0;
-const IN_213: usize = 0;
-const OUT_213: usize = 1;
-fn aiur_fn_213(
-  inp: [G; IN_213],
+const INPUT_SIZE_214: usize = 0;
+const IN_214: usize = 0;
+const OUT_214: usize = 1;
+fn aiur_fn_214(
+  inp: [G; IN_214],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_213], ExecError> {
+) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(20);
     let __v_1: G = G::from_u64(207);
     let __v_2: G = G::from_u64(81);
@@ -20414,23 +20648,24 @@ fn aiur_fn_213(
     let __v_29: G = G::from_u64(39);
     let __v_30: G = G::from_u64(229);
     let __v_31: G = G::from_u64(107);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_213] = [__v_32];
-    if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_214] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_214: usize = 0;
-const IN_214: usize = 0;
-const OUT_214: usize = 1;
-fn aiur_fn_214(
-  inp: [G; IN_214],
+const INPUT_SIZE_215: usize = 0;
+const IN_215: usize = 0;
+const OUT_215: usize = 1;
+fn aiur_fn_215(
+  inp: [G; IN_215],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_214], ExecError> {
+) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(253);
     let __v_1: G = G::from_u64(83);
     let __v_2: G = G::from_u64(232);
@@ -20463,111 +20698,112 @@ fn aiur_fn_214(
     let __v_29: G = G::from_u64(75);
     let __v_30: G = G::from_u64(101);
     let __v_31: G = G::from_u64(135);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_214] = [__v_32];
-    if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_215] = [__v_32];
+    if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_215: usize = 1;
-const IN_215: usize = 1;
-const OUT_215: usize = 1;
-fn aiur_fn_215(
-  inp: [G; IN_215],
+const INPUT_SIZE_216: usize = 1;
+const IN_216: usize = 1;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_215], ExecError> {
+) -> Result<[G; OUT_216], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_3];
-        if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_216] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; 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 { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_5];
-            if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_216] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_7];
-                if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_216] = [__v_7];
+                if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_9];
-                    if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_216] = [__v_9];
+                    if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[211].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_11];
-                        if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_216] = [__v_11];
+                        if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_13];
-                            if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_216] = [__v_13];
+                            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_215] = [__v_15];
-                                if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_216] = [__v_15];
+                                if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_15: G = G::from_u64(0);
-                                let __ret: [G; OUT_215] = [__v_15];
-                                if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_216] = [__v_15];
+                                if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -20586,33 +20822,34 @@ fn aiur_fn_215(
   })
 }
 
-const INPUT_SIZE_216: usize = 3;
-const IN_216: usize = 3;
-const OUT_216: usize = 2;
-fn aiur_fn_216(
-  inp: [G; IN_216],
+const INPUT_SIZE_217: usize = 3;
+const IN_217: usize = 3;
+const OUT_217: usize = 2;
+fn aiur_fn_217(
+  inp: [G; IN_217],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_216], ExecError> {
+) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
     match __v_5.as_canonical_u64() {
       1u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_2]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             match __v_8.as_canonical_u64() {
@@ -20621,9 +20858,9 @@ fn aiur_fn_216(
                 let __v_11: G = G::from_u64(7);
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_216] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_217] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
@@ -20631,9 +20868,9 @@ fn aiur_fn_216(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_216] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_217] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -20646,17 +20883,17 @@ fn aiur_fn_216(
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_216] = [__v_6, __v_10];
-            if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_217] = [__v_6, __v_10];
+            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -20668,16 +20905,16 @@ fn aiur_fn_216(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_216] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_217] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_13: G = __loaded[1];
                 let __v_14: G = __loaded[2];
@@ -20686,17 +20923,17 @@ fn aiur_fn_216(
                   7u64 => {
                     match __v_13.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_16]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_216] = [__v_18, __v_22];
-                        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_217] = [__v_18, __v_22];
+                        if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -20704,9 +20941,9 @@ fn aiur_fn_216(
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(0);
-                        let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_216] = [__v_16, __v_20];
-                        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_217] = [__v_16, __v_20];
+                        if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -20716,9 +20953,9 @@ fn aiur_fn_216(
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_216] = [__v_16, __v_20];
-                    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_217] = [__v_16, __v_20];
+                    if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -20726,65 +20963,65 @@ fn aiur_fn_216(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; 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 { let __r = record.function_queries[218].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_216] = [__v_10, __v_11];
-                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_217] = [__v_10, __v_11];
+                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[211].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_217] = { let __args: [G; IN_217] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; 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 { let __r = record.function_queries[218].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                     let __v_13: G = __r_arr[1];
-                    let __ret: [G; OUT_216] = [__v_12, __v_13];
-                    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_217] = [__v_12, __v_13];
+                    if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                         let __v_15: G = __r_arr[1];
-                        let __ret: [G; OUT_216] = [__v_14, __v_15];
-                        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_217] = [__v_14, __v_15];
+                        if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[521].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
                             let __v_17: G = __r_arr[1];
-                            let __ret: [G; OUT_216] = [__v_16, __v_17];
-                            if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_217] = [__v_16, __v_17];
+                            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; 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 { let __r = record.function_queries[204].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
                             match __v_17.as_canonical_u64() {
                               1u64 => {
@@ -20796,19 +21033,19 @@ fn aiur_fn_216(
                                     let __v_21: G = G::from_u64(0);
                                     let __v_22: G = G::from_u64(0);
                                     let __v_23: G = G::from_u64(0);
-                                    let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_216] = [__v_20, __v_24];
-                                    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                    let __ret: [G; OUT_217] = [__v_20, __v_24];
+                                    if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_20: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_20]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
                                     let __v_22: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_22]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
-                                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                                     let __v_25: G = __loaded[1];
                                     let __v_26: G = __loaded[2];
@@ -20817,7 +21054,7 @@ fn aiur_fn_216(
                                       7u64 => {
                                         match __v_25.as_canonical_u64() {
                                           1u64 => {
-                                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                             let __v_28: G = __loaded[0];
                                             let __v_29: G = __loaded[1];
                                             let __v_30: G = __loaded[2];
@@ -20826,15 +21063,15 @@ fn aiur_fn_216(
                                               7u64 => {
                                                 match __v_29.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_26, __v_30]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_32: G = __r_arr[0];
                                                     let __v_33: G = G::from_u64(1);
                                                     let __v_34: G = G::from_u64(7);
                                                     let __v_35: G = G::from_u64(1);
                                                     let __v_36: G = G::from_u64(0);
-                                                    let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_216] = [__v_33, __v_37];
-                                                    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                    let __ret: [G; OUT_217] = [__v_33, __v_37];
+                                                    if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -20842,9 +21079,9 @@ fn aiur_fn_216(
                                                     let __v_33: G = G::from_u64(0);
                                                     let __v_34: G = G::from_u64(0);
                                                     let __v_35: G = G::from_u64(0);
-                                                    let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_216] = [__v_32, __v_36];
-                                                    if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                    let __ret: [G; OUT_217] = [__v_32, __v_36];
+                                                    if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -20854,9 +21091,9 @@ fn aiur_fn_216(
                                                 let __v_33: G = G::from_u64(0);
                                                 let __v_34: G = G::from_u64(0);
                                                 let __v_35: G = G::from_u64(0);
-                                                let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_216] = [__v_32, __v_36];
-                                                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                let __ret: [G; OUT_217] = [__v_32, __v_36];
+                                                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -20866,9 +21103,9 @@ fn aiur_fn_216(
                                             let __v_29: G = G::from_u64(0);
                                             let __v_30: G = G::from_u64(0);
                                             let __v_31: G = G::from_u64(0);
-                                            let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_216] = [__v_28, __v_32];
-                                            if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __ret: [G; OUT_217] = [__v_28, __v_32];
+                                            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -20878,9 +21115,9 @@ fn aiur_fn_216(
                                         let __v_29: G = G::from_u64(0);
                                         let __v_30: G = G::from_u64(0);
                                         let __v_31: G = G::from_u64(0);
-                                        let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_216] = [__v_28, __v_32];
-                                        if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __ret: [G; OUT_217] = [__v_28, __v_32];
+                                        if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
@@ -20892,9 +21129,9 @@ fn aiur_fn_216(
                                 let __v_19: G = G::from_u64(0);
                                 let __v_20: G = G::from_u64(0);
                                 let __v_21: G = G::from_u64(0);
-                                let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_216] = [__v_18, __v_22];
-                                if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __ret: [G; OUT_217] = [__v_18, __v_22];
+                                if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -20913,18 +21150,19 @@ fn aiur_fn_216(
   })
 }
 
-const INPUT_SIZE_217: usize = 1;
-const IN_217: usize = 1;
-const OUT_217: usize = 2;
-fn aiur_fn_217(
-  inp: [G; IN_217],
+const INPUT_SIZE_218: usize = 1;
+const IN_218: usize = 1;
+const OUT_218: usize = 2;
+fn aiur_fn_218(
+  inp: [G; IN_218],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_217], ExecError> {
+) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -20934,16 +21172,16 @@ fn aiur_fn_217(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_217] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_218] = [__v_4, __v_8];
+        if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -20952,28 +21190,28 @@ fn aiur_fn_217(
           7u64 => {
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_8]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_16: G = G::from_u64(2);
-                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                 let __v_18: G = G::from_u64(1);
                 let __v_19: G = G::from_u64(1);
-                let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_21: G = G::from_u64(0);
-                let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = G::from_u64(3);
                 let __v_25: G = G::from_u64(0);
-                let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_217] = [__v_23, __v_26];
-                if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_218] = [__v_23, __v_26];
+                if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -20981,9 +21219,9 @@ fn aiur_fn_217(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_217] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_218] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -20993,9 +21231,9 @@ fn aiur_fn_217(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_217] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_218] = [__v_10, __v_14];
+            if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -21004,18 +21242,19 @@ fn aiur_fn_217(
   })
 }
 
-const INPUT_SIZE_218: usize = 1;
-const IN_218: usize = 1;
-const OUT_218: usize = 2;
-fn aiur_fn_218(
-  inp: [G; IN_218],
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+const OUT_219: usize = 2;
+fn aiur_fn_219(
+  inp: [G; IN_219],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_218], ExecError> {
+) -> Result<[G; OUT_219], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -21025,16 +21264,16 @@ fn aiur_fn_218(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_218] = [__v_4, __v_8];
-        if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_219] = [__v_4, __v_8];
+        if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -21043,7 +21282,7 @@ fn aiur_fn_218(
           7u64 => {
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 let __v_12: G = __loaded[2];
@@ -21051,15 +21290,15 @@ fn aiur_fn_218(
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
                     let __v_14: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                     let __v_16: G = G::from_u64(1);
                     let __v_17: G = G::from_u64(1);
-                    let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __v_19: G = G::from_u64(0);
-                    let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_218] = [__v_13, __v_20];
-                    if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_219] = [__v_13, __v_20];
+                    if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -21067,9 +21306,9 @@ fn aiur_fn_218(
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
-                    let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_218] = [__v_13, __v_17];
-                    if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_219] = [__v_13, __v_17];
+                    if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -21079,9 +21318,9 @@ fn aiur_fn_218(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_218] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_219] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -21091,9 +21330,9 @@ fn aiur_fn_218(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_218] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_219] = [__v_10, __v_14];
+            if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -21102,34 +21341,35 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 1;
-const IN_219: usize = 1;
-const OUT_219: usize = 0;
-fn aiur_fn_219(
-  inp: [G; IN_219],
+const INPUT_SIZE_220: usize = 1;
+const IN_220: usize = 1;
+const OUT_220: usize = 0;
+fn aiur_fn_220(
+  inp: [G; IN_220],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_219], ExecError> {
+) -> Result<[G; OUT_220], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
       1u64 => {
-        let __ret: [G; OUT_219] = [];
-        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_220] = [];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_2, __v_3]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_219] = [];
-        if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_5]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_220] = [];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -21139,56 +21379,58 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 1;
-const IN_220: usize = 1;
-const OUT_220: usize = 1;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+const INPUT_SIZE_221: usize = 1;
+const IN_221: usize = 1;
+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_220], ExecError> {
+) -> Result<[G; OUT_221], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(65);
-    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __ret: [G; OUT_220] = [__v_2];
-    if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_221] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_221: usize = 2;
-const IN_221: usize = 2;
-const OUT_221: usize = 1;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+const INPUT_SIZE_222: usize = 2;
+const IN_222: usize = 2;
+const OUT_222: usize = 1;
+fn aiur_fn_222(
+  inp: [G; IN_222],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_221], ExecError> {
+) -> Result<[G; OUT_222], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_221] = [__v_1];
-        if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_222] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_3, __v_4]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_6, __v_5]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_221] = [__v_7];
-        if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_222] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -21198,16 +21440,17 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 1;
-const IN_222: usize = 1;
-const OUT_222: usize = 1;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+const INPUT_SIZE_223: usize = 1;
+const IN_223: usize = 1;
+const OUT_223: usize = 1;
+fn aiur_fn_223(
+  inp: [G; IN_223],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_222], ExecError> {
+) -> Result<[G; OUT_223], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(128);
     let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) };
@@ -21219,8 +21462,8 @@ fn aiur_fn_222(
           1u64 => {
             let __v_5: G = G::from_u64(128);
             let __v_6: G = (__v_0 - __v_5);
-            let __ret: [G; OUT_222] = [__v_6];
-            if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_223] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -21235,24 +21478,25 @@ fn aiur_fn_222(
   })
 }
 
-const INPUT_SIZE_223: usize = 2;
-const IN_223: usize = 2;
-const OUT_223: usize = 2;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+const INPUT_SIZE_224: usize = 2;
+const IN_224: usize = 2;
+const OUT_224: usize = 2;
+fn aiur_fn_224(
+  inp: [G; IN_224],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> Result<[G; OUT_224], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(128);
     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_223] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_224] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -21264,7 +21508,7 @@ fn aiur_fn_223(
             let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) };
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_8: G = __loaded[0];
                 let __v_9: G = __loaded[1];
                 let __v_10: G = __loaded[2];
@@ -21274,11 +21518,11 @@ fn aiur_fn_223(
                     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_222] = { let __args: [G; IN_222] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_9]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                     let __v_16: G = (__v_14 + __v_15);
-                    let __ret: [G; OUT_223] = [__v_16, __v_10];
-                    if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_224] = [__v_16, __v_10];
+                    if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -21291,13 +21535,13 @@ fn aiur_fn_223(
                 let __v_9: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record) };
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                     let __v_10: G = __loaded[0];
                     let __v_11: G = __loaded[1];
                     let __v_12: G = __loaded[2];
                     match __v_10.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                         let __v_13: G = __loaded[0];
                         let __v_14: G = __loaded[1];
                         let __v_15: G = __loaded[2];
@@ -21307,11 +21551,11 @@ fn aiur_fn_223(
                             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_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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(64);
                             let __v_22: G = (__v_20 * __v_21);
-                            let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                             let __v_24: G = (__v_22 + __v_23);
                             let __v_25: G = (__v_19 + __v_24);
@@ -21319,8 +21563,8 @@ fn aiur_fn_223(
                             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_223] = [__v_25, __v_15];
-                                if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_224] = [__v_25, __v_15];
+                                if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -21339,19 +21583,19 @@ fn aiur_fn_223(
                     }
                   },
                   _ => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                     let __v_10: G = __loaded[0];
                     let __v_11: G = __loaded[1];
                     let __v_12: G = __loaded[2];
                     match __v_10.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                         let __v_13: G = __loaded[0];
                         let __v_14: G = __loaded[1];
                         let __v_15: G = __loaded[2];
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                             let __v_16: G = __loaded[0];
                             let __v_17: G = __loaded[1];
                             let __v_18: G = __loaded[2];
@@ -21361,15 +21605,15 @@ fn aiur_fn_223(
                                 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_222] = { let __args: [G; IN_222] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_11]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_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_222] = { let __args: [G; IN_222] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_14]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_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_222] = { let __args: [G; IN_222] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_17]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
                                 let __v_30: G = (__v_28 + __v_29);
                                 let __v_31: G = (__v_25 + __v_30);
@@ -21378,8 +21622,8 @@ fn aiur_fn_223(
                                 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_223] = [__v_32, __v_18];
-                                    if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_224] = [__v_32, __v_18];
+                                    if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -21415,123 +21659,125 @@ 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_225: usize = 1;
+const IN_225: usize = 1;
+const OUT_225: usize = 1;
+fn aiur_fn_225(
+  inp: [G; IN_225],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], ExecError> {
+) -> Result<[G; OUT_225], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(1);
     let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_9: G = G::from_u64(2);
-    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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 = G::from_u64(0);
-    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_13: G = G::from_u64(2);
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_24: G = G::from_u64(2);
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
     let __v_26: G = G::from_u64(1);
     let __v_27: G = G::from_u64(1);
-    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_29: G = G::from_u64(0);
-    let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_31: G = G::from_u64(2);
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
-    let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_38: G = G::from_u64(3);
     let __v_39: G = G::from_u64(0);
-    let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_41: G = G::from_u64(3);
     let __v_42: G = G::from_u64(0);
-    let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_40, __v_43, __v_30]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
     let __v_45: G = G::from_u64(3);
     let __v_46: G = G::from_u64(0);
-    let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_224] = [__v_47];
-    if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_225] = [__v_47];
+    if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_225: usize = 4;
-const IN_225: usize = 4;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
+const INPUT_SIZE_226: usize = 4;
+const IN_226: usize = 4;
+const OUT_226: usize = 1;
+fn aiur_fn_226(
+  inp: [G; IN_226],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_225], ExecError> {
+) -> Result<[G; OUT_226], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_225] = [__v_1];
-        if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_226] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_6]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_14: G = G::from_u64(3);
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_17: G = G::from_u64(3);
         let __v_18: G = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = G::from_u64(3);
         let __v_22: G = G::from_u64(0);
-        let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_225] = [__v_23];
-        if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_226] = [__v_23];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -21541,35 +21787,36 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 2;
-const IN_226: usize = 2;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+const INPUT_SIZE_227: usize = 2;
+const IN_227: usize = 2;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_226], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
@@ -21586,10 +21833,10 @@ fn aiur_fn_226(
               1u64 => {
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = G::from_u64(1);
-                let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_14, __v_25]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_28: G = __loaded[1];
                 let __v_29: G = __loaded[2];
@@ -21597,62 +21844,63 @@ fn aiur_fn_226(
                 match __v_27.as_canonical_u64() {
                   4u64 => {
                     let __v_31: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_29, __v_4, __v_31]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_32, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-                    let __ret: [G; OUT_226] = [__v_33];
-                    if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_227] = [__v_33];
+                    if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_31: G = G::from_u64(3);
                     let __v_32: G = G::from_u64(0);
-                    let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_33, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-                    let __ret: [G; OUT_226] = [__v_34];
-                    if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_227] = [__v_34];
+                    if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_226] = [__v_0];
-                if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_227] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_226] = [__v_0];
-            if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_227] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_226] = [__v_0];
-        if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_227] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_227: usize = 2;
-const IN_227: usize = 2;
-const OUT_227: usize = 1;
-fn aiur_fn_227(
-  inp: [G; IN_227],
+const INPUT_SIZE_228: usize = 2;
+const IN_228: usize = 2;
+const OUT_228: usize = 1;
+fn aiur_fn_228(
+  inp: [G; IN_228],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_227], ExecError> {
+) -> Result<[G; OUT_228], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -21661,75 +21909,77 @@ fn aiur_fn_227(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_4]; 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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __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 { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_227] = [__v_7];
-            if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_228] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_227] = [__v_0];
-            if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_228] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_227] = [__v_0];
-        if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_228] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_228: usize = 1;
-const IN_228: usize = 1;
-const OUT_228: usize = 4;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+const INPUT_SIZE_229: usize = 1;
+const IN_229: usize = 1;
+const OUT_229: usize = 4;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_228], ExecError> {
+) -> Result<[G; OUT_229], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_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_122] = { let __args: [G; IN_122] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[1];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_6, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_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_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_9, __v_10]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_228] = [__v_2, __v_5, __v_8, __v_11];
-    if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_229] = [__v_2, __v_5, __v_8, __v_11];
+    if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_229: usize = 1;
-const IN_229: usize = 1;
-const OUT_229: usize = 1;
-fn aiur_fn_229(
-  inp: [G; IN_229],
+const INPUT_SIZE_230: usize = 1;
+const IN_230: usize = 1;
+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_229], ExecError> {
+) -> Result<[G; OUT_230], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0]; let __cu = true; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -21761,93 +22011,94 @@ fn aiur_fn_229(
     let __v_26: G = G::from_u64(0);
     let __v_27: G = G::from_u64(1);
     let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-    let __ret: [G; OUT_229] = [__v_31];
-    if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_230] = [__v_31];
+    if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_230: usize = 2;
-const IN_230: usize = 2;
-const OUT_230: usize = 2;
-fn aiur_fn_230(
-  inp: [G; IN_230],
+const INPUT_SIZE_231: usize = 2;
+const IN_231: usize = 2;
+const OUT_231: usize = 2;
+fn aiur_fn_231(
+  inp: [G; IN_231],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_230], ExecError> {
+) -> Result<[G; OUT_231], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(1);
                 let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_230] = [__v_12, __v_15];
-                if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_231] = [__v_12, __v_15];
+                if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(1);
                 let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_230] = [__v_12, __v_15];
-                if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_231] = [__v_12, __v_15];
+                if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
               0u64 => {
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_230] = [__v_13, __v_16];
-                if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_231] = [__v_13, __v_16];
+                if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_14]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_15, __v_1]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
                     let __v_17: G = __r_arr[1];
                     match __v_16.as_canonical_u64() {
@@ -21855,31 +22106,31 @@ fn aiur_fn_230(
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = G::from_u64(1);
                         let __v_20: G = G::from_u64(1);
-                        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_230] = [__v_18, __v_21];
-                        if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_231] = [__v_18, __v_21];
+                        if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       1u64 => {
                         let __v_18: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_18]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
-                        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_19, __v_1]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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 = __r_arr[1];
                         match __v_20.as_canonical_u64() {
                           0u64 => {
                             let __v_22: G = G::from_u64(0);
-                            let __ret: [G; OUT_230] = [__v_22, __v_21];
-                            if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_231] = [__v_22, __v_21];
+                            if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           1u64 => {
                             let __v_22: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17, __v_21]; 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 { let __r = record.function_queries[237].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                            let __ret: [G; OUT_230] = [__v_22, __v_23];
-                            if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_231] = [__v_22, __v_23];
+                            if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
@@ -21896,9 +22147,9 @@ fn aiur_fn_230(
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(1);
                     let __v_16: G = G::from_u64(1);
-                    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_230] = [__v_14, __v_17];
-                    if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_231] = [__v_14, __v_17];
+                    if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -21911,90 +22162,92 @@ fn aiur_fn_230(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_230] = [__v_9, __v_12];
-        if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_231] = [__v_9, __v_12];
+        if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_231: usize = 2;
-const IN_231: usize = 2;
-const OUT_231: usize = 2;
-fn aiur_fn_231(
-  inp: [G; IN_231],
+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_231], ExecError> {
+) -> Result<[G; OUT_232], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_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_231] = [__v_4, __v_3];
-        if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_232] = [__v_4, __v_3];
+        if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_231] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_232] = [__v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_232: usize = 1;
-const IN_232: usize = 1;
-const OUT_232: usize = 2;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_233: usize = 1;
+const IN_233: usize = 1;
+const OUT_233: usize = 2;
+fn aiur_fn_233(
+  inp: [G; IN_233],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_232], ExecError> {
+) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_232] = [__v_11, __v_12];
-                if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_233] = [__v_11, __v_12];
+                if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_11: G = __loaded[0];
                 let __v_12: G = __loaded[1];
                 let __v_13: G = __loaded[2];
@@ -22003,18 +22256,18 @@ fn aiur_fn_232(
                   7u64 => {
                     match __v_12.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_13]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                         let __v_16: G = __r_arr[1];
-                        let __ret: [G; OUT_232] = [__v_15, __v_16];
-                        if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_233] = [__v_15, __v_16];
+                        if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
                         let __v_16: G = G::from_u64(0);
-                        let __ret: [G; OUT_232] = [__v_15, __v_16];
-                        if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_233] = [__v_15, __v_16];
+                        if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -22022,8 +22275,8 @@ fn aiur_fn_232(
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
-                    let __ret: [G; OUT_232] = [__v_15, __v_16];
-                    if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_233] = [__v_15, __v_16];
+                    if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -22033,8 +22286,8 @@ fn aiur_fn_232(
           _ => {
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_232] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_233] = [__v_9, __v_10];
+            if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -22042,26 +22295,27 @@ fn aiur_fn_232(
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_232] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_233] = [__v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_233: usize = 1;
-const IN_233: usize = 1;
-const OUT_233: usize = 2;
-fn aiur_fn_233(
-  inp: [G; IN_233],
+const INPUT_SIZE_234: usize = 1;
+const IN_234: usize = 1;
+const OUT_234: usize = 2;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_233], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -22074,7 +22328,7 @@ fn aiur_fn_233(
     let __v_10: G = __loaded[9];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -22096,8 +22350,8 @@ fn aiur_fn_233(
               0u64 => {
                 let __v_26: G = G::from_u64(0);
                 let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_233] = [__v_26, __v_27];
-                if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_234] = [__v_26, __v_27];
+                if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -22112,8 +22366,8 @@ fn aiur_fn_233(
                 match __v_33.as_canonical_u64() {
                   1u64 => {
                     let __v_34: G = G::from_u64(1);
-                    let __ret: [G; OUT_233] = [__v_34, __v_31];
-                    if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_234] = [__v_34, __v_31];
+                    if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -22123,8 +22377,8 @@ fn aiur_fn_233(
                       0u64 => {
                         let __v_36: G = G::from_u64(0);
                         let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_233] = [__v_36, __v_37];
-                        if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_234] = [__v_36, __v_37];
+                        if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -22133,15 +22387,15 @@ fn aiur_fn_233(
                         match __v_37.as_canonical_u64() {
                           1u64 => {
                             let __v_38: G = G::from_u64(1);
-                            let __ret: [G; OUT_233] = [__v_38, __v_31];
-                            if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_234] = [__v_38, __v_31];
+                            if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_38: G = G::from_u64(0);
                             let __v_39: G = G::from_u64(0);
-                            let __ret: [G; OUT_233] = [__v_38, __v_39];
-                            if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_234] = [__v_38, __v_39];
+                            if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -22155,8 +22409,8 @@ fn aiur_fn_233(
           _ => {
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_233] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_234] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -22164,32 +22418,33 @@ fn aiur_fn_233(
       _ => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_233] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_234] = [__v_11, __v_12];
+        if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_235: usize = 2;
+const IN_235: usize = 2;
+const OUT_235: usize = 2;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_234], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(64);
     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_234] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_235] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[235].weight(); } record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -22197,59 +22452,61 @@ fn aiur_fn_234(
         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_234] = { let __args: [G; IN_234] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_7]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_234] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_235] = [__v_8, __v_9];
+        if !unconstrained { record.virt += record.function_queries[235].weight(); } record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_235: usize = 1;
-const IN_235: usize = 1;
-const OUT_235: usize = 4;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_236: usize = 1;
+const IN_236: usize = 1;
+const OUT_236: usize = 4;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_235], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0, __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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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_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_234] = { let __args: [G; IN_234] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_3, __v_4]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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_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_234] = { let __args: [G; IN_234] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_7]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_235] = [__v_2, __v_5, __v_8, __v_9];
-    if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_236] = [__v_2, __v_5, __v_8, __v_9];
+    if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_236: usize = 2;
-const IN_236: usize = 2;
-const OUT_236: usize = 1;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+const INPUT_SIZE_237: usize = 2;
+const IN_237: usize = 2;
+const OUT_237: usize = 1;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_236], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = true; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -22303,9 +22560,9 @@ fn aiur_fn_236(
     match __v_36.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_236] = [__v_38];
-        if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_237] = [__v_38];
+        if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -22319,10 +22576,10 @@ fn aiur_fn_236(
             let __v_42: G = (__v_9 + __v_41);
             let __v_43: G = G::from_u64(0);
             let __v_44: G = G::from_u64(0);
-            let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_236] = [__v_46];
-            if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_237] = [__v_46];
+            if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -22339,11 +22596,11 @@ fn aiur_fn_236(
                 let __v_47: G = G::from_u64(0);
                 let __v_48: G = G::from_u64(0);
                 let __v_49: G = G::from_u64(0);
-                let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_236] = [__v_52];
-                if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_237] = [__v_52];
+                if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -22359,12 +22616,12 @@ fn aiur_fn_236(
                 let __v_50: G = G::from_u64(0);
                 let __v_51: G = G::from_u64(0);
                 let __v_52: G = G::from_u64(0);
-                let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_236] = [__v_56];
-                if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_237] = [__v_56];
+                if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -22375,212 +22632,213 @@ fn aiur_fn_236(
   })
 }
 
-const INPUT_SIZE_237: usize = 1;
-const IN_237: usize = 1;
-const OUT_237: usize = 1;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+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_237], ExecError> {
+) -> Result<[G; OUT_238], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_3];
-        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_238] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_5];
-            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_238] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_7];
-                if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_238] = [__v_7];
+                if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_9];
-                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_238] = [__v_9];
+                    if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_11];
-                        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_238] = [__v_11];
+                        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_13];
-                            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_238] = [__v_13];
+                            if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_15];
-                                if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_238] = [__v_15];
+                                if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_17];
-                                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_238] = [__v_17];
+                                    if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_19];
-                                        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_238] = [__v_19];
+                                        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_21];
-                                            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_238] = [__v_21];
+                                            if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_23];
-                                                if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                let __ret: [G; OUT_238] = [__v_23];
+                                                if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_25];
-                                                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_238] = [__v_25];
+                                                    if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_27];
-                                                        if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                        let __ret: [G; OUT_238] = [__v_27];
+                                                        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_29];
-                                                            if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            let __ret: [G; OUT_238] = [__v_29];
+                                                            if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_31];
-                                                                if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                let __ret: [G; OUT_238] = [__v_31];
+                                                                if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                 return Ok(__ret);
                                                               },
                                                               _ => {
-                                                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-                                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_237] = [__v_33];
-                                                                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                    let __ret: [G; OUT_238] = [__v_33];
+                                                                    if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                     return Ok(__ret);
                                                                   },
                                                                   _ => {
                                                                     let __v_33: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_237] = [__v_33];
-                                                                    if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                    let __ret: [G; OUT_238] = [__v_33];
+                                                                    if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                     return Ok(__ret);
                                                                   },
                                                                 }
@@ -22617,56 +22875,57 @@ fn aiur_fn_237(
   })
 }
 
-const INPUT_SIZE_238: usize = 1;
-const IN_238: usize = 1;
-const OUT_238: usize = 1;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+const INPUT_SIZE_239: usize = 1;
+const IN_239: usize = 1;
+const OUT_239: usize = 1;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_238], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
     let __v_21: G = (__v_18 + __v_20);
     let __v_22: G = (__v_16 + __v_21);
@@ -22677,24 +22936,25 @@ fn aiur_fn_238(
     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_238] = [__v_29];
-    if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_239] = [__v_29];
+    if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_239: usize = 1;
-const IN_239: usize = 1;
-const OUT_239: usize = 2;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+const INPUT_SIZE_240: usize = 1;
+const IN_240: usize = 1;
+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_239], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -22704,112 +22964,113 @@ fn aiur_fn_239(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_239] = [__v_5, __v_3];
-            if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_240] = [__v_5, __v_3];
+            if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_239] = [__v_5, __v_8];
-            if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_240] = [__v_5, __v_8];
+            if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; 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 { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_239] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_240] = [__v_7, __v_10];
+            if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_239] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_240] = [__v_7, __v_10];
+            if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2, __v_3]; 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 { let __r = record.function_queries[241].replay_at(__i); record.virt += __r; } 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_239] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_240] = [__v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_239] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_240] = [__v_5, __v_8];
+        if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_240: usize = 2;
-const IN_240: usize = 2;
-const OUT_240: usize = 2;
-fn aiur_fn_240(
-  inp: [G; IN_240],
+const INPUT_SIZE_241: usize = 2;
+const IN_241: usize = 2;
+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_240], ExecError> {
+) -> Result<[G; OUT_241], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_239] = { let __args: [G; IN_239] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_240] = [__v_10, __v_11];
-                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_241] = [__v_10, __v_11];
+                if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(1);
                 let __v_12: G = G::from_u64(1);
-                let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_240] = [__v_10, __v_13];
-                if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_241] = [__v_10, __v_13];
+                if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -22818,9 +23079,9 @@ fn aiur_fn_240(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = G::from_u64(1);
-            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_240] = [__v_8, __v_11];
-            if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_241] = [__v_8, __v_11];
+            if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -22829,95 +23090,97 @@ fn aiur_fn_240(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_240] = [__v_6, __v_9];
-        if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_241] = [__v_6, __v_9];
+        if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-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_242: usize = 1;
+const IN_242: usize = 1;
+const OUT_242: usize = 1;
+fn aiur_fn_242(
+  inp: [G; IN_242],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_241], ExecError> {
+) -> Result<[G; OUT_242], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(7);
     let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
-    let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_241] = [__v_4];
-    if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_242] = [__v_4];
+    if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_242: usize = 1;
-const IN_242: usize = 1;
-const OUT_242: usize = 3;
-fn aiur_fn_242(
-  inp: [G; IN_242],
+const INPUT_SIZE_243: usize = 1;
+const IN_243: usize = 1;
+const OUT_243: usize = 3;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_242], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_14: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                    let __ret: [G; OUT_242] = [__v_13, __v_14, __v_15];
-                    if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_243] = [__v_13, __v_14, __v_15];
+                    if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_16: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                        let __ret: [G; OUT_242] = [__v_15, __v_16, __v_18];
-                        if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_243] = [__v_15, __v_16, __v_18];
+                        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -22925,9 +23188,9 @@ fn aiur_fn_242(
                         let __v_16: G = G::from_u64(0);
                         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_242] = [__v_15, __v_16, __v_19];
-                        if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_243] = [__v_15, __v_16, __v_19];
+                        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -22939,9 +23202,9 @@ fn aiur_fn_242(
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(1);
                 let __v_14: G = G::from_u64(1);
-                let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_242] = [__v_11, __v_12, __v_15];
-                if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_243] = [__v_11, __v_12, __v_15];
+                if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -22951,9 +23214,9 @@ fn aiur_fn_242(
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_242] = [__v_9, __v_10, __v_13];
-            if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_243] = [__v_9, __v_10, __v_13];
+            if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -22963,42 +23226,43 @@ fn aiur_fn_242(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_242] = [__v_5, __v_6, __v_9];
-        if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_243] = [__v_5, __v_6, __v_9];
+        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_243: usize = 2;
-const IN_243: usize = 2;
-const OUT_243: usize = 1;
-fn aiur_fn_243(
-  inp: [G; IN_243],
+const INPUT_SIZE_244: usize = 2;
+const IN_244: usize = 2;
+const OUT_244: usize = 1;
+fn aiur_fn_244(
+  inp: [G; IN_244],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_243], ExecError> {
+) -> Result<[G; OUT_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
   _ => {
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
@@ -23010,9 +23274,9 @@ fn aiur_fn_243(
     break '__mc_1 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     break '__mc_1 [__v_9];
   },
@@ -23023,29 +23287,30 @@ fn aiur_fn_243(
     let __v_10: G = G::from_u64(2);
     let __v_11: G = G::from_u64(1);
     let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_243] = [__v_18];
-    if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_244] = [__v_18];
+    if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_244: usize = 4;
-const IN_244: usize = 4;
-const OUT_244: usize = 1;
-fn aiur_fn_244(
-  inp: [G; IN_244],
+const INPUT_SIZE_245: usize = 4;
+const IN_245: usize = 4;
+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_244], ExecError> {
+) -> Result<[G; OUT_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -23053,34 +23318,34 @@ fn aiur_fn_244(
     let __v_4: G = (__v_0 - __v_2);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_5]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_244] = [__v_6];
-        if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_245] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_6]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_244] = [__v_7];
-            if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_245] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_6]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_244] = [__v_7];
-            if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_245] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -23089,54 +23354,55 @@ fn aiur_fn_244(
   })
 }
 
-const INPUT_SIZE_245: usize = 3;
-const IN_245: usize = 3;
-const OUT_245: usize = 1;
-fn aiur_fn_245(
-  inp: [G; IN_245],
+const INPUT_SIZE_246: usize = 3;
+const IN_246: usize = 3;
+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_245], ExecError> {
+) -> Result<[G; OUT_246], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_245] = [__v_4];
-        if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_246] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __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_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_10]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_245] = [__v_11];
-            if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_246] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_245] = [__v_10];
-            if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_246] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -23145,47 +23411,48 @@ fn aiur_fn_245(
   })
 }
 
-const INPUT_SIZE_246: usize = 4;
-const IN_246: usize = 4;
-const OUT_246: usize = 1;
-fn aiur_fn_246(
-  inp: [G; IN_246],
+const INPUT_SIZE_247: usize = 4;
+const IN_247: usize = 4;
+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_246], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_8]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_246] = [__v_9];
-        if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_247] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_6]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __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_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_5]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -23201,54 +23468,55 @@ fn aiur_fn_246(
         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_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_11]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __v_19: G = (__v_17 - __v_18);
         let __v_20: G = (__v_16 * __v_19);
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_20, __v_11]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __ret: [G; OUT_246] = [__v_21];
-        if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_247] = [__v_21];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_247: usize = 3;
-const IN_247: usize = 3;
-const OUT_247: usize = 1;
-fn aiur_fn_247(
-  inp: [G; IN_247],
+const INPUT_SIZE_248: usize = 3;
+const IN_248: usize = 3;
+const OUT_248: usize = 1;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_247], ExecError> {
+) -> Result<[G; OUT_248], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_247] = [__v_4];
-        if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_248] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __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_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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];
     break '__mc_0 [__v_9];
   },
@@ -23269,31 +23537,31 @@ fn aiur_fn_247(
         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; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_23, __v_22]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_24, __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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_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_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_27]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_247] = [__v_28];
-            if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_248] = [__v_28];
+            if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26, __v_9]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-            let __ret: [G; OUT_247] = [__v_27];
-            if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_248] = [__v_27];
+            if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -23302,44 +23570,45 @@ fn aiur_fn_247(
   })
 }
 
-const INPUT_SIZE_248: usize = 3;
-const IN_248: usize = 3;
-const OUT_248: usize = 1;
-fn aiur_fn_248(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_248], ExecError> {
+) -> Result<[G; OUT_249], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       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; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __v_7: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_248] = [__v_8];
-        if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_249] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __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_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2, __v_4]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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];
     break '__mc_0 [__v_9];
   },
@@ -23349,16 +23618,16 @@ fn aiur_fn_248(
 }
  };
         let __v_9: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
     break '__mc_1 [__v_15];
   },
@@ -23369,7 +23638,7 @@ fn aiur_fn_248(
  };
         let __v_15: G = __mc_out___mc_1[0];
         let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_15]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __v_18: G = (__v_16 - __v_17);
         let __v_19: G = (__v_0 * __v_18);
@@ -23384,20 +23653,20 @@ fn aiur_fn_248(
         let __v_28: G = G::from_u64(0);
         let __v_29: G = G::from_u64(1);
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = { let __values: [G; 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_33, __v_32]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_34, __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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
         match __v_35.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_36];
-            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_249] = [__v_36];
+            if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -23413,12 +23682,12 @@ fn aiur_fn_248(
             let __v_45: G = G::from_u64(0);
             let __v_46: G = G::from_u64(1);
             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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_49: G = { let __values: [G; 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19, __v_15, __v_36, __v_49]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_50];
-            if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_249] = [__v_50];
+            if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -23427,30 +23696,31 @@ fn aiur_fn_248(
   })
 }
 
-const INPUT_SIZE_249: usize = 3;
-const IN_249: usize = 3;
-const OUT_249: usize = 2;
-fn aiur_fn_249(
-  inp: [G; IN_249],
+const INPUT_SIZE_250: usize = 3;
+const IN_250: usize = 3;
+const OUT_250: usize = 2;
+fn aiur_fn_250(
+  inp: [G; IN_250],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_249], ExecError> {
+) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_9: G = (__v_6 + __v_8);
     match __v_9.as_canonical_u64() {
@@ -23463,28 +23733,28 @@ fn aiur_fn_249(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_249] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_250] = [__v_12, __v_16];
+            if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_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_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_241] = { let __args: [G; IN_241] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
     break '__mc_0 [__v_19];
   },
@@ -23492,11 +23762,11 @@ fn aiur_fn_249(
     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_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_243] = { let __args: [G; IN_243] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_24, __v_16]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
     break '__mc_0 [__v_25];
   },
@@ -23505,12 +23775,12 @@ fn aiur_fn_249(
                 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_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_21]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_249] = [__v_20, __v_23];
-                if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_250] = [__v_20, __v_23];
+                if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -23518,9 +23788,9 @@ fn aiur_fn_249(
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
                 let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_249] = [__v_17, __v_21];
-                if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_250] = [__v_17, __v_21];
+                if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -23536,26 +23806,26 @@ fn aiur_fn_249(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_249] = [__v_12, __v_16];
-            if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_250] = [__v_12, __v_16];
+            if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_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_250] = { let __args: [G; IN_250] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_3, __v_15, __v_16]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                 let __v_18: G = __r_arr[1];
-                let __ret: [G; OUT_249] = [__v_17, __v_18];
-                if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_250] = [__v_17, __v_18];
+                if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -23563,9 +23833,9 @@ fn aiur_fn_249(
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
                 let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_249] = [__v_17, __v_21];
-                if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_250] = [__v_17, __v_21];
+                if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -23576,62 +23846,63 @@ fn aiur_fn_249(
   })
 }
 
-const INPUT_SIZE_250: usize = 4;
-const IN_250: usize = 4;
-const OUT_250: usize = 2;
-fn aiur_fn_250(
-  inp: [G; IN_250],
+const INPUT_SIZE_251: usize = 4;
+const IN_251: usize = 4;
+const OUT_251: usize = 2;
+fn aiur_fn_251(
+  inp: [G; IN_251],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_250], ExecError> {
+) -> Result<[G; OUT_251], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[158].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 = (__v_5 + __v_10);
     match __v_11.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_13]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   _ => {
-    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_15]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         break '__mc_0 [__v_20];
       },
@@ -23647,18 +23918,18 @@ fn aiur_fn_250(
         let __v_28: G = G::from_u64(0);
         let __v_29: G = G::from_u64(1);
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_32: G = { let __values: [G; 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_31: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_33: G = G::from_u64(1);
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15, __v_32]; 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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_34]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3, __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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
         break '__mc_0 [__v_39];
       },
@@ -23669,12 +23940,12 @@ fn aiur_fn_250(
             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_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_20]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_21]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-            let __ret: [G; OUT_250] = [__v_19, __v_22];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_251] = [__v_19, __v_22];
+            if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -23682,55 +23953,55 @@ fn aiur_fn_250(
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
             let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_250] = [__v_16, __v_20];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_251] = [__v_16, __v_20];
+            if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_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_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_15, __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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
     break '__mc_1 [__v_19];
   },
   _ => {
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_22: G = (__v_21 - __v_15);
         let __v_23: G = G::from_u64(1);
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_244] = { let __args: [G; IN_244] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_26, __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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         break '__mc_1 [__v_27];
       },
       _ => {
-        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -23740,34 +24011,34 @@ fn aiur_fn_250(
             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_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_16]; 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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_35, __v_36]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
             break '__mc_1 [__v_37];
           },
           _ => {
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_245] = { let __args: [G; IN_245] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_16]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
               _ => {
-                let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_3, __v_15, __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 { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
@@ -23782,12 +24053,12 @@ fn aiur_fn_250(
             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_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_21]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_22]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-            let __ret: [G; OUT_250] = [__v_20, __v_23];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_251] = [__v_20, __v_23];
+            if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -23795,9 +24066,9 @@ fn aiur_fn_250(
             let __v_18: G = G::from_u64(0);
             let __v_19: G = G::from_u64(0);
             let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_250] = [__v_17, __v_21];
-            if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_251] = [__v_17, __v_21];
+            if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -23806,36 +24077,37 @@ fn aiur_fn_250(
   })
 }
 
-const INPUT_SIZE_251: usize = 2;
-const IN_251: usize = 2;
-const OUT_251: usize = 1;
-fn aiur_fn_251(
-  inp: [G; IN_251],
+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_251], ExecError> {
+) -> Result<[G; OUT_252], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_251] = [__v_0];
-        if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_252] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(3);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_251] = [__v_8];
-        if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_252] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -23845,264 +24117,265 @@ fn aiur_fn_251(
   })
 }
 
-const INPUT_SIZE_252: usize = 3;
-const IN_252: usize = 3;
-const OUT_252: usize = 2;
-fn aiur_fn_252(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_252], ExecError> {
+) -> Result<[G; OUT_253], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_114] = { let __args: [G; IN_114] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_252] = [__v_5, __v_8];
-        if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_253] = [__v_5, __v_8];
+        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_119] = { let __args: [G; IN_119] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_252] = [__v_7, __v_10];
-            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_253] = [__v_7, __v_10];
+            if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __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 { let __r = record.function_queries[126].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                let __ret: [G; OUT_252] = [__v_9, __v_12];
-                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_253] = [__v_9, __v_12];
+                if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                    let __ret: [G; OUT_252] = [__v_11, __v_14];
-                    if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_253] = [__v_11, __v_14];
+                    if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_14]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_15]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                        let __ret: [G; OUT_252] = [__v_13, __v_16];
-                        if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_253] = [__v_13, __v_16];
+                        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_133] = { let __args: [G; IN_133] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_16]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                            let __ret: [G; OUT_252] = [__v_15, __v_18];
-                            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_253] = [__v_15, __v_18];
+                            if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-                                let __ret: [G; OUT_252] = [__v_17, __v_20];
-                                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_253] = [__v_17, __v_20];
+                                if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_138(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } } else { aiur_fn_138(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_20]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_21]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-                                    let __ret: [G; OUT_252] = [__v_19, __v_22];
-                                    if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_253] = [__v_19, __v_22];
+                                    if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_22]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_23]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-                                        let __ret: [G; OUT_252] = [__v_21, __v_24];
-                                        if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_253] = [__v_21, __v_24];
+                                        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_24]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_25]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-                                            let __ret: [G; OUT_252] = [__v_23, __v_26];
-                                            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_253] = [__v_23, __v_26];
+                                            if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_26]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_27]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-                                                let __ret: [G; OUT_252] = [__v_25, __v_28];
-                                                if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                let __ret: [G; OUT_253] = [__v_25, __v_28];
+                                                if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_28]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_29]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-                                                    let __ret: [G; OUT_252] = [__v_27, __v_30];
-                                                    if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    let __ret: [G; OUT_253] = [__v_27, __v_30];
+                                                    if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __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 { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_30]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-                                                        let __ret: [G; OUT_252] = [__v_29, __v_31];
-                                                        if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                        let __ret: [G; OUT_253] = [__v_29, __v_31];
+                                                        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_32]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-                                                            let __ret: [G; OUT_252] = [__v_31, __v_33];
-                                                            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            let __ret: [G; OUT_253] = [__v_31, __v_33];
+                                                            if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -24110,9 +24383,9 @@ fn aiur_fn_252(
                                                             let __v_32: G = G::from_u64(0);
                                                             let __v_33: G = G::from_u64(0);
                                                             let __v_34: G = G::from_u64(0);
-                                                            let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                            let __ret: [G; OUT_252] = [__v_31, __v_35];
-                                                            if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                            let __ret: [G; OUT_253] = [__v_31, __v_35];
+                                                            if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                             return Ok(__ret);
                                                           },
                                                         }
@@ -24145,53 +24418,54 @@ fn aiur_fn_252(
   })
 }
 
-const INPUT_SIZE_253: usize = 2;
-const IN_253: usize = 2;
-const OUT_253: usize = 3;
-fn aiur_fn_253(
-  inp: [G; IN_253],
+const INPUT_SIZE_254: usize = 2;
+const IN_254: usize = 2;
+const OUT_254: usize = 3;
+fn aiur_fn_254(
+  inp: [G; IN_254],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_253], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
           0u64 => {
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = G::from_u64(1);
-            let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_253] = [__v_8, __v_0, __v_11];
-            if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_254] = [__v_8, __v_0, __v_11];
+            if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_11]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_13]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_16: G = __loaded[1];
                 let __v_17: G = __loaded[2];
@@ -24201,17 +24475,17 @@ fn aiur_fn_253(
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_19: G = G::from_u64(1);
-                        let __ret: [G; OUT_253] = [__v_19, __v_12, __v_17];
-                        if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_254] = [__v_19, __v_12, __v_17];
+                        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(1);
                         let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22];
-                        if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22];
+                        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -24220,9 +24494,9 @@ fn aiur_fn_253(
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(1);
                     let __v_21: G = G::from_u64(1);
-                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_253] = [__v_19, __v_0, __v_22];
-                    if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_254] = [__v_19, __v_0, __v_22];
+                    if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -24231,9 +24505,9 @@ fn aiur_fn_253(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(1);
-                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_253] = [__v_11, __v_0, __v_14];
-                if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_254] = [__v_11, __v_0, __v_14];
+                if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -24244,25 +24518,26 @@ fn aiur_fn_253(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_253] = [__v_6, __v_0, __v_9];
-        if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_254] = [__v_6, __v_0, __v_9];
+        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_254: usize = 2;
-const IN_254: usize = 2;
-const OUT_254: usize = 1;
-fn aiur_fn_254(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_254], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
@@ -24276,129 +24551,130 @@ fn aiur_fn_254(
     let __v_10: G = G::from_u64(0);
     let __v_11: G = G::from_u64(1);
     let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_22: G = G::from_u64(0);
-    let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_254] = [__v_27];
-        if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_255] = [__v_27];
+        if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_25: G = G::from_u64(2);
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(1);
-        let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_30: G = G::from_u64(0);
-        let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_32: G = G::from_u64(7);
         let __v_33: G = G::from_u64(0);
         let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_36: G = G::from_u64(3);
         let __v_37: G = G::from_u64(3);
         let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_40: G = G::from_u64(0);
-        let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_42: G = G::from_u64(3);
         let __v_43: G = G::from_u64(0);
-        let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_254] = [__v_44];
-        if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_255] = [__v_44];
+        if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_255: usize = 1;
-const IN_255: usize = 1;
-const OUT_255: usize = 1;
-fn aiur_fn_255(
-  inp: [G; IN_255],
+const INPUT_SIZE_256: usize = 1;
+const IN_256: usize = 1;
+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_255], ExecError> {
+) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_255] = [__v_0];
-        if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_256] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5, __v_6]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_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_118] = { let __args: [G; IN_118] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_255] = [__v_0];
-                    if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_256] = [__v_0];
+                    if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_14]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                    let __ret: [G; OUT_255] = [__v_16];
-                    if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_256] = [__v_16];
+                    if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_255] = [__v_0];
-                if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_256] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_255] = [__v_0];
-            if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_256] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -24407,115 +24683,117 @@ 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_257: usize = 3;
+const IN_257: usize = 3;
+const OUT_257: usize = 2;
+fn aiur_fn_257(
+  inp: [G; IN_257],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_256], ExecError> {
+) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_251] = { let __args: [G; IN_251] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_2]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_256] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_257] = [__v_4, __v_5];
+        if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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 __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(3);
         let __v_12: G = G::from_u64(3);
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+        let __v_14: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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 = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_18: G = G::from_u64(1);
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_17, __v_2]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __ret: [G; OUT_256] = [__v_18, __v_19];
-        if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_257] = [__v_18, __v_19];
+        if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_257: usize = 1;
-const IN_257: usize = 1;
-const OUT_257: usize = 1;
-fn aiur_fn_257(
-  inp: [G; IN_257],
+const INPUT_SIZE_258: usize = 1;
+const IN_258: usize = 1;
+const OUT_258: usize = 1;
+fn aiur_fn_258(
+  inp: [G; IN_258],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_257], ExecError> {
+) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
             let __v_14: G = __loaded[3];
             match __v_11.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_257] = [__v_17];
-                    if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_258] = [__v_17];
+                    if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_10, __v_20]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
-                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                         let __v_23: G = __loaded[1];
                         let __v_24: G = __loaded[2];
@@ -24523,22 +24801,22 @@ fn aiur_fn_257(
                         match __v_22.as_canonical_u64() {
                           0u64 => {
                             let __v_26: G = G::from_bool((__v_23 == G::ZERO));
-                            let __ret: [G; OUT_257] = [__v_26];
-                            if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_258] = [__v_26];
+                            if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_26: G = G::from_u64(0);
-                            let __ret: [G; OUT_257] = [__v_26];
-                            if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_258] = [__v_26];
+                            if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
-                        let __ret: [G; OUT_257] = [__v_20];
-                        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_258] = [__v_20];
+                        if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -24547,40 +24825,41 @@ fn aiur_fn_257(
               },
               _ => {
                 let __v_15: G = G::from_u64(0);
-                let __ret: [G; OUT_257] = [__v_15];
-                if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_258] = [__v_15];
+                if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_257] = [__v_9];
-            if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_258] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_257] = [__v_5];
-        if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_258] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_258: usize = 5;
-const IN_258: usize = 5;
-const OUT_258: usize = 2;
-fn aiur_fn_258(
-  inp: [G; IN_258],
+const INPUT_SIZE_259: usize = 5;
+const IN_259: usize = 5;
+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_258], ExecError> {
+) -> Result<[G; OUT_259], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -24594,15 +24873,15 @@ fn aiur_fn_258(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_258] = [__v_7, __v_11];
-        if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_259] = [__v_7, __v_11];
+        if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -24611,18 +24890,18 @@ fn aiur_fn_258(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_258] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_259] = [__v_10, __v_14];
+            if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_13]; 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 { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             match __v_14.as_canonical_u64() {
               0u64 => {
@@ -24630,40 +24909,40 @@ fn aiur_fn_258(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_258] = [__v_15, __v_19];
-                if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_259] = [__v_15, __v_19];
+                if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_17]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_15]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_20, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_22]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_18]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-                    let __ret: [G; OUT_258] = [__v_21, __v_24];
-                    if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_259] = [__v_21, __v_24];
+                    if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_15, __v_9, __v_18]; 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 { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
                     let __v_22: G = __r_arr[1];
-                    let __ret: [G; OUT_258] = [__v_21, __v_22];
-                    if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_259] = [__v_21, __v_22];
+                    if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -24679,28 +24958,29 @@ fn aiur_fn_258(
   })
 }
 
-const INPUT_SIZE_259: usize = 3;
-const IN_259: usize = 3;
-const OUT_259: usize = 2;
-fn aiur_fn_259(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_259], ExecError> {
+) -> Result<[G; OUT_260], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -24712,32 +24992,32 @@ fn aiur_fn_259(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_259] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_260] = [__v_10, __v_14];
+            if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                let __ret: [G; OUT_259] = [__v_16, __v_19];
-                if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_260] = [__v_16, __v_19];
+                if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -24745,9 +25025,9 @@ fn aiur_fn_259(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_259] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_260] = [__v_14, __v_18];
+                if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -24765,34 +25045,34 @@ fn aiur_fn_259(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_259] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_260] = [__v_10, __v_14];
+                if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_14]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
                     let __v_16: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_17]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-                    let __ret: [G; OUT_259] = [__v_16, __v_20];
-                    if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_260] = [__v_16, __v_20];
+                    if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -24800,9 +25080,9 @@ fn aiur_fn_259(
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
-                    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_259] = [__v_14, __v_18];
-                    if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_260] = [__v_14, __v_18];
+                    if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -24810,11 +25090,11 @@ fn aiur_fn_259(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1, __v_3]; 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 { let __r = record.function_queries[261].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_259] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_260] = [__v_8, __v_9];
+            if !unconstrained { record.virt += record.function_queries[260].weight(); } record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -24823,16 +25103,17 @@ 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_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_260], ExecError> {
+) -> Result<[G; OUT_261], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -24844,41 +25125,41 @@ fn aiur_fn_260(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_260] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_261] = [__v_5, __v_9];
+        if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_6]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_10, __v_12]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_15]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
                     let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_14, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                    let __ret: [G; OUT_260] = [__v_17, __v_18];
-                    if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_261] = [__v_17, __v_18];
+                    if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -24886,9 +25167,9 @@ fn aiur_fn_260(
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
-                    let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_260] = [__v_15, __v_19];
-                    if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_261] = [__v_15, __v_19];
+                    if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -24898,24 +25179,24 @@ fn aiur_fn_260(
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_260] = [__v_13, __v_17];
-                if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_261] = [__v_13, __v_17];
+                if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_8]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_6, __v_12, __v_1]; 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 { let __r = record.function_queries[262].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_260] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_261] = [__v_13, __v_14];
+                if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -24923,9 +25204,9 @@ fn aiur_fn_260(
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
-                let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_260] = [__v_13, __v_17];
-                if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_261] = [__v_13, __v_17];
+                if !unconstrained { record.virt += record.function_queries[261].weight(); } record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -24936,43 +25217,44 @@ fn aiur_fn_260(
   })
 }
 
-const INPUT_SIZE_261: usize = 4;
-const IN_261: usize = 4;
-const OUT_261: usize = 2;
-fn aiur_fn_261(
-  inp: [G; IN_261],
+const INPUT_SIZE_262: usize = 4;
+const IN_262: usize = 4;
+const OUT_262: usize = 2;
+fn aiur_fn_262(
+  inp: [G; IN_262],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_261], ExecError> {
+) -> Result<[G; OUT_262], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_15]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_16]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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 __v_18: G = (__v_14 - __v_17);
     let __v_19: G = (__v_13 * __v_18);
@@ -24984,25 +25266,25 @@ fn aiur_fn_261(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_261] = [__v_22, __v_26];
-        if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_262] = [__v_22, __v_26];
+        if !unconstrained { record.virt += record.function_queries[262].weight(); } record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_22]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_2, __v_23]; 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 { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } 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_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_261] = [__v_26, __v_25];
-                if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_262] = [__v_26, __v_25];
+                if !unconstrained { record.virt += record.function_queries[262].weight(); } record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -25010,19 +25292,19 @@ fn aiur_fn_261(
                 let __v_27: G = G::from_u64(0);
                 let __v_28: G = G::from_u64(0);
                 let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_261] = [__v_26, __v_30];
-                if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_262] = [__v_26, __v_30];
+                if !unconstrained { record.virt += record.function_queries[262].weight(); } record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(2);
-            let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_23]; 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 { let __r = record.function_queries[263].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-            let __ret: [G; OUT_261] = [__v_24, __v_25];
-            if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_262] = [__v_24, __v_25];
+            if !unconstrained { record.virt += record.function_queries[262].weight(); } record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -25031,16 +25313,17 @@ fn aiur_fn_261(
   })
 }
 
-const INPUT_SIZE_262: usize = 4;
-const IN_262: usize = 4;
-const OUT_262: usize = 1;
-fn aiur_fn_262(
-  inp: [G; IN_262],
+const INPUT_SIZE_263: usize = 4;
+const IN_263: usize = 4;
+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_262], ExecError> {
+) -> Result<[G; OUT_263], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -25048,35 +25331,36 @@ fn aiur_fn_262(
     let __v_4: G = G::from_u64(2);
     let __v_5: G = G::from_u64(1);
     let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_10: G = G::from_u64(3);
     let __v_11: G = G::from_u64(3);
     let __v_12: G = G::from_u64(0);
-    let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+    let __v_13: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-    let __ret: [G; OUT_262] = [__v_17];
-    if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_263] = [__v_17];
+    if !unconstrained { record.virt += record.function_queries[263].weight(); } record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_263: usize = 10;
-const IN_263: usize = 10;
-const OUT_263: usize = 8;
-fn aiur_fn_263(
-  inp: [G; IN_263],
+const INPUT_SIZE_264: usize = 10;
+const IN_264: usize = 10;
+const OUT_264: usize = 8;
+fn aiur_fn_264(
+  inp: [G; IN_264],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_263], ExecError> {
+) -> Result<[G; OUT_264], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -25089,26 +25373,26 @@ fn aiur_fn_263(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_263] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_264] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+            if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25117,13 +25401,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25132,13 +25416,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               2u64 => {
                 let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25147,13 +25431,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               3u64 => {
                 let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25162,13 +25446,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               4u64 => {
                 let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25177,13 +25461,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               5u64 => {
                 let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25192,13 +25476,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               6u64 => {
                 let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25207,13 +25491,13 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __v_16: G = __r_arr[2];
@@ -25222,8 +25506,8 @@ fn aiur_fn_263(
                 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_263] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_264] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                if !unconstrained { record.virt += record.function_queries[264].weight(); } record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -25237,26 +25521,27 @@ fn aiur_fn_263(
   })
 }
 
-const INPUT_SIZE_264: usize = 2;
-const IN_264: usize = 2;
-const OUT_264: usize = 1;
-fn aiur_fn_264(
-  inp: [G; IN_264],
+const INPUT_SIZE_265: usize = 2;
+const IN_265: usize = 2;
+const OUT_265: usize = 1;
+fn aiur_fn_265(
+  inp: [G; IN_265],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_264], ExecError> {
+) -> Result<[G; OUT_265], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_264] = [__v_0];
-        if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_265] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -25264,18 +25549,18 @@ fn aiur_fn_264(
           1u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(1);
-            let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_264] = [__v_7];
-            if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_265] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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_264] = { let __args: [G; IN_264] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4, __v_6]; 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 { let __r = record.function_queries[265].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_264] = [__v_7];
-            if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_265] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[265].weight(); } record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -25287,16 +25572,17 @@ fn aiur_fn_264(
   })
 }
 
-const INPUT_SIZE_265: usize = 1;
-const IN_265: usize = 1;
-const OUT_265: usize = 1;
-fn aiur_fn_265(
-  inp: [G; IN_265],
+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_265], ExecError> {
+) -> Result<[G; OUT_266], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(0);
@@ -25307,7 +25593,7 @@ fn aiur_fn_265(
     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_263] = { let __args: [G; IN_263] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__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[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[264].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -25317,9 +25603,9 @@ fn aiur_fn_265(
     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_264] = { let __args: [G; IN_264] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __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 { let __r = record.function_queries[265].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_21: G = __loaded[1];
     let __v_22: G = __loaded[2];
@@ -25327,18 +25613,18 @@ fn aiur_fn_265(
   1u64 => {
     let __v_23: G = G::from_u64(1);
     let __v_24: G = G::from_u64(1);
-    let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_0 [__v_25];
   },
   _ => {
-    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_19]; 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 { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
 }
  };
     let __v_23: G = __mc_out___mc_0[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_24: G = __loaded[0];
     let __v_25: G = __loaded[1];
     let __v_26: G = __loaded[2];
@@ -25351,25 +25637,25 @@ fn aiur_fn_265(
     let __v_33: G = __loaded[9];
     match __v_24.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
         match __v_34.as_canonical_u64() {
           1u64 => {
             let __v_35: G = G::from_u64(1);
             let __v_36: G = G::from_u64(1);
-            let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_265] = [__v_37];
-            if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_266] = [__v_37];
+            if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(1);
             let __v_37: G = G::from_u64(1);
-            let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_265] = [__v_39];
-            if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_266] = [__v_39];
+            if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -25379,27 +25665,28 @@ fn aiur_fn_265(
       },
       _ => {
         let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_265] = [__v_35];
-        if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_266] = [__v_35];
+        if !unconstrained { record.virt += record.function_queries[266].weight(); } record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_266: usize = 1;
-const IN_266: usize = 1;
-const OUT_266: usize = 1;
-fn aiur_fn_266(
-  inp: [G; IN_266],
+const INPUT_SIZE_267: usize = 1;
+const IN_267: usize = 1;
+const OUT_267: usize = 1;
+fn aiur_fn_267(
+  inp: [G; IN_267],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_266], ExecError> {
+) -> Result<[G; OUT_267], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
+    let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -25413,51 +25700,51 @@ fn aiur_fn_266(
       0u64 => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_266] = [__v_12];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_267] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_266] = [__v_13];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_267] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_10: G = G::from_u64(2);
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_266] = [__v_13];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_267] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_266] = [__v_13];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_267] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(4);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_266] = [__v_13];
-        if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_267] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[267].weight(); } record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -25467,19 +25754,20 @@ fn aiur_fn_266(
   })
 }
 
-const INPUT_SIZE_267: usize = 2;
-const IN_267: usize = 2;
-const OUT_267: usize = 1;
-fn aiur_fn_267(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_267], ExecError> {
+) -> Result<[G; OUT_268], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -25494,24 +25782,24 @@ fn aiur_fn_267(
       1u64 => {
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_267] = [__v_14];
-        if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_268] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_1]; 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 { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
-        let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_267] = [__v_17];
-        if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_268] = [__v_17];
+        if !unconstrained { record.virt += record.function_queries[268].weight(); } record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -25521,22 +25809,23 @@ fn aiur_fn_267(
   })
 }
 
-const INPUT_SIZE_268: usize = 5;
-const IN_268: usize = 5;
-const OUT_268: usize = 1;
-fn aiur_fn_268(
-  inp: [G; IN_268],
+const INPUT_SIZE_269: usize = 5;
+const IN_269: usize = 5;
+const OUT_269: usize = 1;
+fn aiur_fn_269(
+  inp: [G; IN_269],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_268], ExecError> {
+) -> Result<[G; OUT_269], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -25557,169 +25846,169 @@ fn aiur_fn_268(
     let __v_22: G = __loaded[17];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(1);
-        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_24]; 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 { let __r = record.function_queries[267].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_28];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_23: G = G::from_u64(0);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_26];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_26];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; 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 { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_28];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_4]; 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 { let __r = record.function_queries[268].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(2);
         let __v_27: G = G::from_u64(0);
-        let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_28];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(8);
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_268] = { let __args: [G; IN_268] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_22, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-        let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_28];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; 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 { let __r = record.function_queries[281].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_25]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_26: G = G::from_u64(7);
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(0);
-        let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_29];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_29];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_24]; 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 { let __r = record.function_queries[281].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_25]; 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 { let __r = record.function_queries[266].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_30];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_30];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_23: G = G::from_u64(3);
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_27];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_27];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_23: G = G::from_u64(4);
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_27];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_27];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       9u64 => {
         let __v_23: G = G::from_u64(5);
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_6, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_7, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_27];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_27];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       10u64 => {
         let __v_23: G = G::from_u64(6);
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_14, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_16, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-        let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_268] = [__v_27];
-        if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_269] = [__v_27];
+        if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       11u64 => {
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_23]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_26: G = __loaded[1];
         let __v_27: G = __loaded[2];
         match __v_25.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_26, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-            let __ret: [G; OUT_268] = [__v_28];
-            if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_269] = [__v_28];
+            if !unconstrained { record.virt += record.function_queries[269].weight(); } record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -25734,16 +26023,17 @@ fn aiur_fn_268(
   })
 }
 
-const INPUT_SIZE_269: usize = 17;
-const IN_269: usize = 17;
-const OUT_269: usize = 12;
-fn aiur_fn_269(
-  inp: [G; IN_269],
+const INPUT_SIZE_270: usize = 17;
+const IN_270: usize = 17;
+const OUT_270: usize = 12;
+fn aiur_fn_270(
+  inp: [G; IN_270],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_269], ExecError> {
+) -> Result<[G; OUT_270], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -25763,18 +26053,18 @@ fn aiur_fn_269(
     let __v_16: G = inp[16];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_10, __v_12, __v_13, __v_14, __v_15]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_11, __v_12, __v_13, __v_14, __v_15]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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];
         match __v_0.as_canonical_u64() {
           0u64 => {
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            if !unconstrained { record.virt += record.function_queries[270].weight(); } record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
@@ -25792,15 +26082,15 @@ fn aiur_fn_269(
             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_269] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
-            if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_270] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
+            if !unconstrained { record.virt += record.function_queries[270].weight(); } record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_20: G = G::from_u64(2);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_269] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_270] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            if !unconstrained { record.virt += record.function_queries[270].weight(); } record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -25812,16 +26102,17 @@ fn aiur_fn_269(
   })
 }
 
-const INPUT_SIZE_270: usize = 14;
-const IN_270: usize = 14;
-const OUT_270: usize = 12;
-fn aiur_fn_270(
-  inp: [G; IN_270],
+const INPUT_SIZE_271: usize = 14;
+const IN_271: usize = 14;
+const OUT_271: usize = 12;
+fn aiur_fn_271(
+  inp: [G; IN_271],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_270], ExecError> {
+) -> Result<[G; OUT_271], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -25838,30 +26129,31 @@ fn aiur_fn_270(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(0);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_270] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        if !unconstrained { record.virt += record.function_queries[271].weight(); } record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_271: usize = 14;
-const IN_271: usize = 14;
-const OUT_271: usize = 12;
-fn aiur_fn_271(
-  inp: [G; IN_271],
+const INPUT_SIZE_272: usize = 14;
+const IN_272: usize = 14;
+const OUT_272: usize = 12;
+fn aiur_fn_272(
+  inp: [G; IN_272],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_271], ExecError> {
+) -> Result<[G; OUT_272], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -25878,32 +26170,33 @@ fn aiur_fn_271(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_9, __v_10, __v_11, __v_12, __v_13]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(4);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_271] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_272] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        if !unconstrained { record.virt += record.function_queries[272].weight(); } record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_272: usize = 1;
-const IN_272: usize = 1;
-const OUT_272: usize = 1;
-fn aiur_fn_272(
-  inp: [G; IN_272],
+const INPUT_SIZE_273: usize = 1;
+const IN_273: usize = 1;
+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_272], ExecError> {
+) -> Result<[G; OUT_273], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -25943,17 +26236,17 @@ fn aiur_fn_272(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_272] = [__v_37];
-        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_273] = [__v_37];
+        if !unconstrained { record.virt += record.function_queries[273].weight(); } record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_36]; 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 { let __r = record.function_queries[273].replay_at(__i); record.virt += __r; } 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_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_272] = [__v_39];
-        if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_273] = [__v_39];
+        if !unconstrained { record.virt += record.function_queries[273].weight(); } record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -25963,19 +26256,20 @@ fn aiur_fn_272(
   })
 }
 
-const INPUT_SIZE_273: usize = 2;
-const IN_273: usize = 2;
-const OUT_273: usize = 34;
-fn aiur_fn_273(
-  inp: [G; IN_273],
+const INPUT_SIZE_274: usize = 2;
+const IN_274: usize = 2;
+const OUT_274: usize = 34;
+fn aiur_fn_274(
+  inp: [G; IN_274],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_273], ExecError> {
+) -> Result<[G; OUT_274], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -26016,14 +26310,14 @@ fn aiur_fn_273(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_273] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-            if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_274] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+            if !unconstrained { record.virt += record.function_queries[274].weight(); } record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_38: G = G::from_u64(1);
             let __v_39: G = (__v_1 - __v_38);
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_37, __v_39]; 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 { let __r = record.function_queries[274].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
             let __v_41: G = __r_arr[1];
             let __v_42: G = __r_arr[2];
@@ -26058,8 +26352,8 @@ fn aiur_fn_273(
             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_273] = [__v_40, __v_41, __v_42, __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];
-            if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_274] = [__v_40, __v_41, __v_42, __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];
+            if !unconstrained { record.virt += record.function_queries[274].weight(); } record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -26071,16 +26365,17 @@ fn aiur_fn_273(
   })
 }
 
-const INPUT_SIZE_274: usize = 33;
-const IN_274: usize = 33;
-const OUT_274: usize = 12;
-fn aiur_fn_274(
-  inp: [G; IN_274],
+const INPUT_SIZE_275: usize = 33;
+const IN_275: usize = 33;
+const OUT_275: usize = 12;
+fn aiur_fn_275(
+  inp: [G; IN_275],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_274], ExecError> {
+) -> Result<[G; OUT_275], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -26116,36 +26411,37 @@ fn aiur_fn_274(
     let __v_32: G = inp[32];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25, __v_29, __v_30, __v_31, __v_32]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
         let __v_34: G = G::from_u64(5);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_272] = { let __args: [G; IN_272] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_26]; 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 { let __r = record.function_queries[273].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
         let __v_39: G = G::from_u64(0);
-        let __ret: [G; OUT_274] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
-        if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_275] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
+        if !unconstrained { record.virt += record.function_queries[275].weight(); } record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_275: usize = 40;
-const IN_275: usize = 40;
-const OUT_275: usize = 12;
-fn aiur_fn_275(
-  inp: [G; IN_275],
+const INPUT_SIZE_276: usize = 40;
+const IN_276: usize = 40;
+const OUT_276: usize = 12;
+fn aiur_fn_276(
+  inp: [G; IN_276],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_275], ExecError> {
+) -> Result<[G; OUT_276], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -26188,43 +26484,44 @@ fn aiur_fn_275(
     let __v_39: G = inp[39];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_33, __v_36, __v_37, __v_38, __v_39]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
         let __v_41: G = G::from_u64(6);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_275] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
-        if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_276] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
+        if !unconstrained { record.virt += record.function_queries[276].weight(); } record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_276: usize = 6;
-const IN_276: usize = 6;
-const OUT_276: usize = 1;
-fn aiur_fn_276(
-  inp: [G; IN_276],
+const INPUT_SIZE_277: usize = 6;
+const IN_277: usize = 6;
+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_276], ExecError> {
+) -> Result<[G; OUT_277], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -26240,26 +26537,26 @@ fn aiur_fn_276(
       1u64 => {
         let __v_17: G = G::from_u64(1);
         let __v_18: G = G::from_u64(1);
-        let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_276] = [__v_19];
-        if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_277] = [__v_19];
+        if !unconstrained { record.virt += record.function_queries[277].weight(); } record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_15, __v_1, __v_2, __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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_276] = { let __args: [G; IN_276] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; 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 { let __r = record.function_queries[277].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-            let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_276] = [__v_23];
-            if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_277] = [__v_23];
+            if !unconstrained { record.virt += record.function_queries[277].weight(); } record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -26271,16 +26568,17 @@ fn aiur_fn_276(
   })
 }
 
-const INPUT_SIZE_277: usize = 50;
-const IN_277: usize = 50;
-const OUT_277: usize = 12;
-fn aiur_fn_277(
-  inp: [G; IN_277],
+const INPUT_SIZE_278: usize = 50;
+const IN_278: usize = 50;
+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_277], ExecError> {
+) -> Result<[G; OUT_278], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -26333,42 +26631,43 @@ fn aiur_fn_277(
     let __v_49: G = inp[49];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_42, __v_46, __v_47, __v_48, __v_49]; 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 { let __r = record.function_queries[269].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; 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 { let __r = record.function_queries[277].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
         let __v_53: G = G::from_u64(7);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_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[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; 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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_277] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
-        if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_278] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
+        if !unconstrained { record.virt += record.function_queries[278].weight(); } record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_278: usize = 1;
-const IN_278: usize = 1;
-const OUT_278: usize = 48;
-fn aiur_fn_278(
-  inp: [G; IN_278],
+const INPUT_SIZE_279: usize = 1;
+const IN_279: usize = 1;
+const OUT_279: usize = 48;
+fn aiur_fn_279(
+  inp: [G; IN_279],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_278], ExecError> {
+) -> Result<[G; OUT_279], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -26406,10 +26705,10 @@ fn aiur_fn_278(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(2);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __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_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } 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_111] = { let __args: [G; IN_111] = [__v_37]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -26459,7 +26758,7 @@ fn aiur_fn_278(
     let __v_84: G = __r_arr[46];
     let __v_85: G = __r_arr[47];
     let __v_86: G = __r_arr[48];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_87: G = __loaded[0];
     let __v_88: G = __loaded[1];
     let __v_89: G = __loaded[2];
@@ -26474,24 +26773,25 @@ fn aiur_fn_278(
     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_278] = [__v_38, __v_39, __v_40, __v_41, __v_42, __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];
-    if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_279] = [__v_38, __v_39, __v_40, __v_41, __v_42, __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];
+    if !unconstrained { record.virt += record.function_queries[279].weight(); } record.function_queries[279].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_279: usize = 1;
-const IN_279: usize = 1;
-const OUT_279: usize = 1;
-fn aiur_fn_279(
-  inp: [G; IN_279],
+const INPUT_SIZE_280: usize = 1;
+const IN_280: usize = 1;
+const OUT_280: usize = 1;
+fn aiur_fn_280(
+  inp: [G; IN_280],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_279], ExecError> {
+) -> Result<[G; OUT_280], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -26529,16 +26829,16 @@ fn aiur_fn_279(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(3);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_38: G = __loaded[0];
     let __v_39: G = __loaded[1];
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_279] = [__v_39];
-        if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_280] = [__v_39];
+        if !unconstrained { record.virt += record.function_queries[280].weight(); } record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -26548,18 +26848,19 @@ fn aiur_fn_279(
   })
 }
 
-const INPUT_SIZE_280: usize = 1;
-const IN_280: usize = 1;
-const OUT_280: usize = 1;
-fn aiur_fn_280(
-  inp: [G; IN_280],
+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_280], ExecError> {
+) -> Result<[G; OUT_281], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -26597,46 +26898,47 @@ fn aiur_fn_280(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(4);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __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_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_280] = [__v_37];
-    if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = record.function_queries[21].replay_at(__i); record.virt += __r; } 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_281] = [__v_37];
+    if !unconstrained { record.virt += record.function_queries[281].weight(); } record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_281: usize = 2;
-const IN_281: usize = 2;
-const OUT_281: usize = 1;
-fn aiur_fn_281(
-  inp: [G; IN_281],
+const INPUT_SIZE_282: usize = 2;
+const IN_282: usize = 2;
+const OUT_282: usize = 1;
+fn aiur_fn_282(
+  inp: [G; IN_282],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_281], ExecError> {
+) -> Result<[G; OUT_282], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_281] = [__v_2];
-        if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_282] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_281] = [__v_2];
-            if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_282] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_281] = [__v_2];
-            if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_282] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -26645,14 +26947,14 @@ fn aiur_fn_281(
         match __v_1.as_canonical_u64() {
           1u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_281] = [__v_2];
-            if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_282] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_281] = [__v_2];
-            if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_282] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[282].weight(); } record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -26664,16 +26966,17 @@ fn aiur_fn_281(
   })
 }
 
-const INPUT_SIZE_282: usize = 14;
-const IN_282: usize = 14;
-const OUT_282: usize = 1;
-fn aiur_fn_282(
-  inp: [G; IN_282],
+const INPUT_SIZE_283: usize = 14;
+const IN_283: usize = 14;
+const OUT_283: usize = 1;
+fn aiur_fn_283(
+  inp: [G; IN_283],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_282], ExecError> {
+) -> Result<[G; OUT_283], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -26690,22 +26993,22 @@ fn aiur_fn_282(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0, __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 { let __r = record.function_queries[282].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         match __v_14.as_canonical_u64() {
           0u64 => {
             let __v_15: G = G::from_u64(1);
             let __v_16: G = G::from_u64(1);
-            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_282] = [__v_17];
-            if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_283] = [__v_17];
+            if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_12, __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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-            let __ret: [G; OUT_282] = [__v_15];
-            if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_283] = [__v_15];
+            if !unconstrained { record.virt += record.function_queries[283].weight(); } record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -26714,18 +27017,19 @@ fn aiur_fn_282(
   })
 }
 
-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_284: usize = 1;
+const IN_284: usize = 1;
+const OUT_284: usize = 1;
+fn aiur_fn_284(
+  inp: [G; IN_284],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_283], ExecError> {
+) -> Result<[G; OUT_284], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -26778,25 +27082,25 @@ fn aiur_fn_283(
       _ => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_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_281] = { let __args: [G; IN_281] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_2, __v_3]; 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 { let __r = record.function_queries[282].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
     match __v_50.as_canonical_u64() {
       0u64 => {
         let __v_51: G = G::from_u64(1);
         let __v_52: G = G::from_u64(1);
-        let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         break '__mc_0 [__v_53];
       },
       _ => {
         let __v_51: G = G::from_u64(0);
         let __v_52: G = G::from_u64(1);
         let __v_53: G = G::from_u64(1);
-        let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         break '__mc_0 [__v_55];
       },
     }
@@ -26804,7 +27108,7 @@ fn aiur_fn_283(
 }
  };
             let __v_50: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_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; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_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[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[270].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -26817,16 +27121,16 @@ fn aiur_fn_283(
             let __v_60: G = __r_arr[9];
             let __v_61: G = __r_arr[10];
             let __v_62: G = __r_arr[11];
-            let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_283] = [__v_63];
-            if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_284] = [__v_63];
+            if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = G::from_u64(1);
-            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__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[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[271].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -26839,16 +27143,16 @@ fn aiur_fn_283(
             let __v_61: G = __r_arr[9];
             let __v_62: G = __r_arr[10];
             let __v_63: G = __r_arr[11];
-            let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_283] = [__v_64];
-            if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_284] = [__v_64];
+            if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = G::from_u64(1);
-            let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__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[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[272].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
             let __v_53: G = __r_arr[1];
             let __v_54: G = __r_arr[2];
@@ -26861,18 +27165,18 @@ fn aiur_fn_283(
             let __v_61: G = __r_arr[9];
             let __v_62: G = __r_arr[10];
             let __v_63: G = __r_arr[11];
-            let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_283] = [__v_64];
-            if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_284] = [__v_64];
+            if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           7u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__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[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[285].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __ret: [G; OUT_283] = [__v_49];
-                if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_284] = [__v_49];
+                if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -26880,12 +27184,12 @@ fn aiur_fn_283(
           6u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_285] = { let __args: [G; IN_285] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-                let __ret: [G; OUT_283] = [__v_50];
-                if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_284] = [__v_50];
+                if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -26893,14 +27197,14 @@ fn aiur_fn_283(
           4u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_286] = { let __args: [G; IN_286] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_18, __v_49, __v_50]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-                let __ret: [G; OUT_283] = [__v_51];
-                if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_284] = [__v_51];
+                if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -26908,12 +27212,12 @@ fn aiur_fn_283(
           5u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_287] = { let __args: [G; IN_287] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_10, __v_49]; 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 { let __r = record.function_queries[288].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-                let __ret: [G; OUT_283] = [__v_50];
-                if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_284] = [__v_50];
+                if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -26922,10 +27226,10 @@ fn aiur_fn_283(
             let __v_49: G = G::from_u64(0);
             let __v_50: G = G::from_u64(1);
             let __v_51: G = G::from_u64(1);
-            let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_54: G = G::from_u64(0);
-            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
             let __v_57: G = __r_arr[2];
@@ -26938,9 +27242,9 @@ fn aiur_fn_283(
             let __v_64: G = __r_arr[9];
             let __v_65: G = __r_arr[10];
             let __v_66: G = __r_arr[11];
-            let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_283] = [__v_67];
-            if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_284] = [__v_67];
+            if !unconstrained { record.virt += record.function_queries[284].weight(); } record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -26952,16 +27256,17 @@ fn aiur_fn_283(
   })
 }
 
-const INPUT_SIZE_284: usize = 10;
-const IN_284: usize = 10;
-const OUT_284: usize = 1;
-fn aiur_fn_284(
-  inp: [G; IN_284],
+const INPUT_SIZE_285: usize = 10;
+const IN_285: usize = 10;
+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_284], ExecError> {
+) -> Result<[G; OUT_285], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -26972,7 +27277,7 @@ fn aiur_fn_284(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_9]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -27025,7 +27330,7 @@ fn aiur_fn_284(
       _ => {
         match __v_10.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__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[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } 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 __v_58: G = __r_arr[0];
             let __v_59: G = __r_arr[1];
             let __v_60: G = __r_arr[2];
@@ -27073,11 +27378,11 @@ fn aiur_fn_284(
             let __v_102: G = __r_arr[44];
             match __v_58.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0]; let __cu = true; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if true => { 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_103: G = __r_arr[0];
-                let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__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; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__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[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[283].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
-                let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__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; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__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[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[270].replay_at(__i); record.virt += __r; } 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_105: G = __r_arr[0];
                 let __v_106: G = __r_arr[1];
                 let __v_107: G = __r_arr[2];
@@ -27090,9 +27395,9 @@ fn aiur_fn_284(
                 let __v_114: G = __r_arr[9];
                 let __v_115: G = __r_arr[10];
                 let __v_116: G = __r_arr[11];
-                let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_284] = [__v_117];
-                if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_285] = [__v_117];
+                if !unconstrained { record.virt += record.function_queries[285].weight(); } record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -27109,19 +27414,20 @@ fn aiur_fn_284(
   })
 }
 
-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_286: usize = 2;
+const IN_286: usize = 2;
+const OUT_286: usize = 1;
+fn aiur_fn_286(
+  inp: [G; IN_286],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_285], ExecError> {
+) -> Result<[G; OUT_286], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -27174,7 +27480,7 @@ fn aiur_fn_285(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __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 { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
             let __v_52: G = __r_arr[2];
@@ -27222,9 +27528,9 @@ fn aiur_fn_285(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__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; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[275].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
                 let __v_97: G = __r_arr[1];
                 let __v_98: G = __r_arr[2];
@@ -27237,9 +27543,9 @@ fn aiur_fn_285(
                 let __v_105: G = __r_arr[9];
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
-                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_285] = [__v_108];
-                if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_286] = [__v_108];
+                if !unconstrained { record.virt += record.function_queries[286].weight(); } record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -27256,20 +27562,21 @@ fn aiur_fn_285(
   })
 }
 
-const INPUT_SIZE_286: usize = 3;
-const IN_286: usize = 3;
-const OUT_286: usize = 1;
-fn aiur_fn_286(
-  inp: [G; IN_286],
+const INPUT_SIZE_287: usize = 3;
+const IN_287: usize = 3;
+const OUT_287: usize = 1;
+fn aiur_fn_287(
+  inp: [G; IN_287],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_286], ExecError> {
+) -> Result<[G; OUT_287], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -27322,7 +27629,7 @@ fn aiur_fn_286(
       _ => {
         match __v_3.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4, __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 { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -27372,7 +27679,7 @@ fn aiur_fn_286(
               1u64 => {
                 match __v_52.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_78, __v_2]; 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 { let __r = record.function_queries[274].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
                     let __v_97: G = __r_arr[1];
                     let __v_98: G = __r_arr[2];
@@ -27407,9 +27714,9 @@ fn aiur_fn_286(
                     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_291] = { let __args: [G; IN_291] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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_130: G = __r_arr[0];
-                    let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__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[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[276].replay_at(__i); record.virt += __r; } 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_131: G = __r_arr[0];
                     let __v_132: G = __r_arr[1];
                     let __v_133: G = __r_arr[2];
@@ -27422,9 +27729,9 @@ fn aiur_fn_286(
                     let __v_140: G = __r_arr[9];
                     let __v_141: G = __r_arr[10];
                     let __v_142: G = __r_arr[11];
-                    let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_286] = [__v_143];
-                    if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_287] = [__v_143];
+                    if !unconstrained { record.virt += record.function_queries[287].weight(); } record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -27443,19 +27750,20 @@ fn aiur_fn_286(
   })
 }
 
-const INPUT_SIZE_287: usize = 2;
-const IN_287: usize = 2;
-const OUT_287: usize = 1;
-fn aiur_fn_287(
-  inp: [G; IN_287],
+const INPUT_SIZE_288: usize = 2;
+const IN_288: usize = 2;
+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_287], ExecError> {
+) -> Result<[G; OUT_288], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -27508,7 +27816,7 @@ fn aiur_fn_287(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __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 { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
             let __v_51: G = __r_arr[1];
             let __v_52: G = __r_arr[2];
@@ -27556,9 +27864,9 @@ fn aiur_fn_287(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__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; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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_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[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[278].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
                 let __v_97: G = __r_arr[1];
                 let __v_98: G = __r_arr[2];
@@ -27571,9 +27879,9 @@ fn aiur_fn_287(
                 let __v_105: G = __r_arr[9];
                 let __v_106: G = __r_arr[10];
                 let __v_107: G = __r_arr[11];
-                let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_287] = [__v_108];
-                if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_288] = [__v_108];
+                if !unconstrained { record.virt += record.function_queries[288].weight(); } record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -27590,19 +27898,20 @@ fn aiur_fn_287(
   })
 }
 
-const INPUT_SIZE_288: usize = 2;
-const IN_288: usize = 2;
-const OUT_288: usize = 45;
-fn aiur_fn_288(
-  inp: [G; IN_288],
+const INPUT_SIZE_289: usize = 2;
+const IN_289: usize = 2;
+const OUT_289: usize = 45;
+fn aiur_fn_289(
+  inp: [G; IN_289],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_288], ExecError> {
+) -> Result<[G; OUT_289], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -27654,14 +27963,14 @@ fn aiur_fn_288(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_288] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
-            if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_289] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
+            if !unconstrained { record.virt += record.function_queries[289].weight(); } record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 - __v_49);
-            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_48, __v_50]; 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 { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
             let __v_53: G = __r_arr[2];
@@ -27707,8 +28016,8 @@ fn aiur_fn_288(
             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_288] = [__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];
-            if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_289] = [__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];
+            if !unconstrained { record.virt += record.function_queries[289].weight(); } record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -27720,16 +28029,17 @@ fn aiur_fn_288(
   })
 }
 
-const INPUT_SIZE_289: usize = 1;
-const IN_289: usize = 1;
-const OUT_289: usize = 8;
-fn aiur_fn_289(
-  inp: [G; IN_289],
+const INPUT_SIZE_290: usize = 1;
+const IN_290: usize = 1;
+const OUT_290: usize = 8;
+fn aiur_fn_290(
+  inp: [G; IN_290],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_289], ExecError> {
+) -> Result<[G; OUT_290], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
     let __v_1: G = G::from_u8(__gb[0]);
@@ -27744,31 +28054,32 @@ fn aiur_fn_289(
     if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
     if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
     if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __r_arr: [G; OUT_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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     if (__v_9 != __v_0) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) });
     }
-    let __ret: [G; OUT_289] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_290] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[290].weight(); } record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-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_291: usize = 3;
+const IN_291: usize = 3;
+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_290], ExecError> {
+) -> Result<[G; OUT_291], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_2]; 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 { let __r = record.function_queries[289].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -27814,7 +28125,7 @@ fn aiur_fn_290(
     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_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; 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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
@@ -27891,62 +28202,64 @@ fn aiur_fn_290(
     let __v_100: G = __mc_out___mc_0[44];
     let __v_101: G = G::from_u64(1);
     let __v_102: G = G::from_u64(1);
-    let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_104: G = G::from_u64(1);
     let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_107: G = G::from_u64(1);
     let __v_108: G = G::from_u64(1);
-    let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_110: G = G::from_u64(1);
     let __v_111: G = G::from_u64(1);
-    let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_113: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_290] = [__v_114];
-    if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_291] = [__v_114];
+    if !unconstrained { record.virt += record.function_queries[291].weight(); } record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-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_292: usize = 2;
+const IN_292: usize = 2;
+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_291], ExecError> {
+) -> Result<[G; OUT_292], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_0, __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 { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __ret: [G; OUT_291] = [__v_3];
-    if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_292] = [__v_3];
+    if !unconstrained { record.virt += record.function_queries[292].weight(); } record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_292: usize = 4;
-const IN_292: usize = 4;
-const OUT_292: usize = 1;
-fn aiur_fn_292(
-  inp: [G; IN_292],
+const INPUT_SIZE_293: usize = 4;
+const IN_293: usize = 4;
+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_292], ExecError> {
+) -> Result<[G; OUT_293], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -27998,22 +28311,22 @@ fn aiur_fn_292(
       1u64 => {
         let __v_51: G = G::from_u64(1);
         let __v_52: G = G::from_u64(1);
-        let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_292] = [__v_53];
-        if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_293] = [__v_53];
+        if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_1, __v_3]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_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_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_1, __v_50, __v_54]; 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 { let __r = record.function_queries[293].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-        let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_292] = [__v_56];
-        if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_293] = [__v_56];
+        if !unconstrained { record.virt += record.function_queries[293].weight(); } record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -28023,75 +28336,76 @@ fn aiur_fn_292(
   })
 }
 
-const INPUT_SIZE_293: usize = 1;
-const IN_293: usize = 1;
-const OUT_293: usize = 1;
-fn aiur_fn_293(
-  inp: [G; IN_293],
+const INPUT_SIZE_294: usize = 1;
+const IN_294: usize = 1;
+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_293], ExecError> {
+) -> Result<[G; OUT_294], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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(0);
-        let __ret: [G; OUT_293] = [__v_4];
-        if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_294] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_293] = [__v_4];
-        if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_294] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_293] = [__v_4];
-        if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_294] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2]; 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 { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__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 { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } 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_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_293] = [__v_6];
-                if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_294] = [__v_6];
+                if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_6: G = G::from_u64(1);
-                let __ret: [G; OUT_293] = [__v_6];
-                if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_294] = [__v_6];
+                if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_293] = [__v_6];
-            if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_294] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__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 { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_293] = [__v_4];
-        if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_294] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[294].weight(); } record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -28101,114 +28415,115 @@ fn aiur_fn_293(
   })
 }
 
-const INPUT_SIZE_294: usize = 2;
-const IN_294: usize = 2;
-const OUT_294: usize = 1;
-fn aiur_fn_294(
-  inp: [G; IN_294],
+const INPUT_SIZE_295: usize = 2;
+const IN_295: usize = 2;
+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_294], ExecError> {
+) -> Result<[G; OUT_295], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; 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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_294] = [__v_10];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; 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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_294] = [__v_10];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -28216,14 +28531,14 @@ fn aiur_fn_294(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_294] = [__v_9];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_294] = [__v_8];
-            if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_295] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[295].weight(); } record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -28235,39 +28550,40 @@ fn aiur_fn_294(
   })
 }
 
-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_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_295], ExecError> {
+) -> Result<[G; OUT_296], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_295] = [__v_8];
-            if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_296] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_295] = [__v_8];
-            if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_296] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -28276,15 +28592,15 @@ fn aiur_fn_295(
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_295] = [__v_8];
-            if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_296] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -28292,8 +28608,8 @@ fn aiur_fn_295(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_295] = [__v_9];
-                if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_296] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
@@ -28301,15 +28617,15 @@ fn aiur_fn_295(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_295] = [__v_10];
-                    if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_296] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; 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 { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_295] = [__v_10];
-                    if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_296] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[296].weight(); } record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -28334,39 +28650,40 @@ fn aiur_fn_295(
   })
 }
 
-const INPUT_SIZE_296: usize = 2;
-const IN_296: usize = 2;
-const OUT_296: usize = 1;
-fn aiur_fn_296(
-  inp: [G; IN_296],
+const INPUT_SIZE_297: usize = 2;
+const IN_297: usize = 2;
+const OUT_297: usize = 1;
+fn aiur_fn_297(
+  inp: [G; IN_297],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_296], ExecError> {
+) -> Result<[G; OUT_297], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_296] = [__v_5];
-        if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_297] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_296] = [__v_8];
-            if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_297] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -28374,25 +28691,25 @@ fn aiur_fn_296(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_296] = [__v_9];
-                if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_297] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 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_296] = { let __args: [G; IN_296] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_7]; 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 { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_296] = [__v_10];
-                    if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_297] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; 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 { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_296] = [__v_10];
-                    if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_297] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[297].weight(); } record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -28417,39 +28734,40 @@ fn aiur_fn_296(
   })
 }
 
-const INPUT_SIZE_297: usize = 2;
-const IN_297: usize = 2;
-const OUT_297: usize = 1;
-fn aiur_fn_297(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_297], ExecError> {
+) -> Result<[G; OUT_298], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -28458,22 +28776,22 @@ fn aiur_fn_297(
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[298].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_297] = [__v_8];
-            if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_298] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[298].weight(); } record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -28488,19 +28806,20 @@ fn aiur_fn_297(
   })
 }
 
-const INPUT_SIZE_298: usize = 2;
-const IN_298: usize = 2;
-const OUT_298: usize = 2;
-fn aiur_fn_298(
-  inp: [G; IN_298],
+const INPUT_SIZE_299: usize = 2;
+const IN_299: usize = 2;
+const OUT_299: usize = 2;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_298], ExecError> {
+) -> Result<[G; OUT_299], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -28510,10 +28829,10 @@ fn aiur_fn_298(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_298] = [__v_5, __v_10];
-        if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_299] = [__v_5, __v_10];
+        if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -28522,9 +28841,9 @@ fn aiur_fn_298(
           1u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_298] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_299] = [__v_6, __v_8];
+            if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -28532,18 +28851,18 @@ fn aiur_fn_298(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_298] = [__v_7, __v_1];
-                if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_299] = [__v_7, __v_1];
+                if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __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 { let __r = record.function_queries[299].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
                 let __v_9: G = G::from_u64(0);
-                let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_298] = [__v_7, __v_10];
-                if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_299] = [__v_7, __v_10];
+                if !unconstrained { record.virt += record.function_queries[299].weight(); } record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -28563,37 +28882,38 @@ fn aiur_fn_298(
   })
 }
 
-const INPUT_SIZE_299: usize = 3;
-const IN_299: usize = 3;
-const OUT_299: usize = 1;
-fn aiur_fn_299(
-  inp: [G; IN_299],
+const INPUT_SIZE_300: usize = 3;
+const IN_300: usize = 3;
+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_299], ExecError> {
+) -> Result<[G; OUT_300], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_299] = [__v_11];
-        if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_300] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
@@ -28602,10 +28922,10 @@ fn aiur_fn_299(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_299] = [__v_11];
-                if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_300] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
@@ -28613,11 +28933,11 @@ fn aiur_fn_299(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[300].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                    let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_299] = [__v_12];
-                    if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_300] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -28625,15 +28945,15 @@ fn aiur_fn_299(
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(0);
-                        let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_299] = [__v_13];
-                        if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_300] = [__v_13];
+                        if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __ret: [G; OUT_299] = [__v_0];
-                        if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_300] = [__v_0];
+                        if !unconstrained { record.virt += record.function_queries[300].weight(); } record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -28660,39 +28980,40 @@ 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_301: usize = 2;
+const IN_301: usize = 2;
+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_300], ExecError> {
+) -> Result<[G; OUT_301], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -28701,24 +29022,24 @@ fn aiur_fn_300(
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_300] = [__v_8];
-            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_301] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 match __v_10.as_canonical_u64() {
@@ -28729,24 +29050,24 @@ fn aiur_fn_300(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[301].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_300] = [__v_14];
-                            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_301] = [__v_14];
+                            if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_300] = [__v_14];
-                            if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_301] = [__v_14];
+                            if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_300] = [__v_13];
-                        if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_301] = [__v_13];
+                        if !unconstrained { record.virt += record.function_queries[301].weight(); } record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -28767,46 +29088,47 @@ fn aiur_fn_300(
   })
 }
 
-const INPUT_SIZE_301: usize = 1;
-const IN_301: usize = 1;
-const OUT_301: usize = 1;
-fn aiur_fn_301(
-  inp: [G; IN_301],
+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_301], ExecError> {
+) -> Result<[G; OUT_302], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_301] = [__v_4];
-        if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_302] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } 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_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_301] = [__v_5];
-                if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_302] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_301] = [__v_6];
-                if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_302] = [__v_6];
+                if !unconstrained { record.virt += record.function_queries[302].weight(); } record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -28823,46 +29145,47 @@ fn aiur_fn_301(
   })
 }
 
-const INPUT_SIZE_302: usize = 2;
-const IN_302: usize = 2;
-const OUT_302: usize = 1;
-fn aiur_fn_302(
-  inp: [G; IN_302],
+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_302], ExecError> {
+) -> Result<[G; OUT_303], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_302] = [__v_0];
-        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_303] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_302] = [__v_0];
-            if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_303] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+            let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+                let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 match __v_10.as_canonical_u64() {
@@ -28871,21 +29194,21 @@ fn aiur_fn_302(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __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 { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_302] = [__v_15];
-                        if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_303] = [__v_15];
+                        if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         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_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __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 { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-                            let __ret: [G; OUT_302] = [__v_14];
-                            if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_303] = [__v_14];
+                            if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -28893,18 +29216,18 @@ fn aiur_fn_302(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_302] = [__v_17];
-                                if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __ret: [G; OUT_303] = [__v_17];
+                                if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                                let __ret: [G; OUT_302] = [__v_15];
-                                if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_303] = [__v_15];
+                                if !unconstrained { record.virt += record.function_queries[303].weight(); } record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -28938,41 +29261,42 @@ 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_304: usize = 3;
+const IN_304: usize = 3;
+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_303], ExecError> {
+) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_303] = [__v_0];
-        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_304] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_303] = [__v_6];
-            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_304] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_303] = [__v_0];
-            if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_304] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -28981,30 +29305,31 @@ fn aiur_fn_303(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __ret: [G; OUT_303] = [__v_3];
-        if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_304] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[304].weight(); } record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_304: usize = 3;
-const IN_304: usize = 3;
-const OUT_304: usize = 1;
-fn aiur_fn_304(
-  inp: [G; IN_304],
+const INPUT_SIZE_305: usize = 3;
+const IN_305: usize = 3;
+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_304], ExecError> {
+) -> Result<[G; OUT_305], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -29013,24 +29338,24 @@ fn aiur_fn_304(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_304] = [__v_14];
-        if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_305] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_6]; 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 { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
@@ -29038,15 +29363,15 @@ fn aiur_fn_304(
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(0);
-                    let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_304] = [__v_13];
-                    if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_305] = [__v_13];
+                    if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_304] = [__v_0];
-                    if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_305] = [__v_0];
+                    if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29058,20 +29383,20 @@ fn aiur_fn_304(
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = G::from_u64(1);
                 let __v_12: G = G::from_u64(1);
-                let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_304] = [__v_15];
-                if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_305] = [__v_15];
+                if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[305].replay_at(__i); record.virt += __r; } 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];
-                let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_304] = [__v_12];
-                if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_305] = [__v_12];
+                if !unconstrained { record.virt += record.function_queries[305].weight(); } record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -29085,21 +29410,22 @@ fn aiur_fn_304(
   })
 }
 
-const INPUT_SIZE_305: usize = 4;
-const IN_305: usize = 4;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_306: usize = 4;
+const IN_306: usize = 4;
+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_305], ExecError> {
+) -> Result<[G; OUT_306], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -29108,62 +29434,62 @@ fn aiur_fn_305(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_305] = [__v_19];
-        if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_306] = [__v_19];
+        if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_7]; 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 { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } 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_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_299] = { let __args: [G; IN_299] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_9, __v_2, __v_3]; 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 { let __r = record.function_queries[300].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_305] = [__v_14];
-                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_306] = [__v_14];
+                if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = G::from_u64(1);
-                let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_305] = [__v_20];
-                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_306] = [__v_20];
+                if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } 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 __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_305] = [__v_13];
-                if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_306] = [__v_13];
+                if !unconstrained { record.virt += record.function_queries[306].weight(); } record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -29177,83 +29503,84 @@ fn aiur_fn_305(
   })
 }
 
-const INPUT_SIZE_306: usize = 4;
-const IN_306: usize = 4;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_307: usize = 4;
+const IN_307: usize = 4;
+const OUT_307: usize = 1;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_306], ExecError> {
+) -> Result<[G; OUT_307], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; 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 { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_306] = [__v_7];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __v_8, __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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_306] = [__v_9];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1, __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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_1, __v_2, __v_7]; 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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_306] = [__v_8];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_6, __v_1, __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 { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_306] = [__v_7];
-        if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_307] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1]; 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 { let __r = record.function_queries[299].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_3, __v_1, __v_2]; 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 { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } 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];
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_9, __v_8, __v_5, __v_2]; 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 { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __ret: [G; OUT_306] = [__v_10];
-            if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_307] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_306] = [__v_3];
-                if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_307] = [__v_3];
+                if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_3, __v_1, __v_5, __v_2]; 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 { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_306] = [__v_9];
-                if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_307] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[307].weight(); } record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -29270,76 +29597,77 @@ fn aiur_fn_306(
   })
 }
 
-const INPUT_SIZE_307: usize = 5;
-const IN_307: usize = 5;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+const INPUT_SIZE_308: usize = 5;
+const IN_308: usize = 5;
+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_307], ExecError> {
+) -> Result<[G; OUT_308], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; 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 { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_307] = [__v_8];
-        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_308] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_2, __v_9, __v_10]; 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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __ret: [G; OUT_307] = [__v_11];
-        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_308] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_6, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_8]; 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 { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_307] = [__v_9];
-        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_308] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_6, __v_7, __v_2, __v_3, __v_8]; 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 { let __r = record.function_queries[308].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __ret: [G; OUT_307] = [__v_9];
-        if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_308] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_6, __v_2]; 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 { let __r = record.function_queries[299].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_2, __v_3]; 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 { let __r = record.function_queries[304].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_10, __v_9, __v_6, __v_3]; 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 { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_9, __v_3, __v_11]; 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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_307] = [__v_12];
-            if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_308] = [__v_12];
+            if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -29348,17 +29676,17 @@ fn aiur_fn_307(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_2, __v_6, __v_3]; 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 { let __r = record.function_queries[306].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     break '__mc_0 [__v_10];
   },
 }
  };
             let __v_10: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_2, __v_3, __v_10]; 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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __ret: [G; OUT_307] = [__v_11];
-            if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_308] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[308].weight(); } record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -29373,37 +29701,38 @@ fn aiur_fn_307(
   })
 }
 
-const INPUT_SIZE_308: usize = 2;
-const IN_308: usize = 2;
-const OUT_308: usize = 1;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+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_308], ExecError> {
+) -> Result<[G; OUT_309], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_308] = [__v_0];
-        if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_309] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[309].weight(); } record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3, __v_1]; 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 { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_1]; 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 { let __r = record.function_queries[309].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_308] = [__v_8];
-        if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_309] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[309].weight(); } record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -29413,53 +29742,54 @@ fn aiur_fn_308(
   })
 }
 
-const INPUT_SIZE_309: usize = 2;
-const IN_309: usize = 2;
-const OUT_309: usize = 1;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_310: usize = 2;
+const IN_310: usize = 2;
+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_309], ExecError> {
+) -> Result<[G; OUT_310], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_309] = [__v_0];
-        if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_310] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           _ => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_8, __v_5]; 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 { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __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 { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_309] = [__v_12];
-                    if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_310] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_5, __v_8]; 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 { let __r = record.function_queries[298].replay_at(__i); record.virt += __r; } 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
@@ -29482,7 +29812,7 @@ fn aiur_fn_309(
 }
  };
     let __v_13: G = __mc_out___mc_1[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_14: G = __loaded[0];
     let __v_15: G = __loaded[1];
     let __v_16: G = __loaded[2];
@@ -29492,7 +29822,7 @@ fn aiur_fn_309(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7]; 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 { let __r = record.function_queries[302].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
     let __v_18: G = G::from_u64(1);
     let __v_19: G = (__v_17 + __v_18);
@@ -29524,7 +29854,7 @@ fn aiur_fn_309(
     break '__mc_3 [__v_7];
   },
   0u64 => {
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_14: G = __loaded[0];
     let __v_15: G = __loaded[1];
     let __v_16: G = __loaded[2];
@@ -29533,7 +29863,7 @@ fn aiur_fn_309(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_7, __v_10]; 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 { let __r = record.function_queries[303].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         break '__mc_3 [__v_17];
       },
@@ -29548,11 +29878,11 @@ fn aiur_fn_309(
 }
  };
                     let __v_14: G = __mc_out___mc_3[0];
-                    let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_15, __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 { let __r = record.function_queries[310].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-                    let __ret: [G; OUT_309] = [__v_16];
-                    if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_310] = [__v_16];
+                    if !unconstrained { record.virt += record.function_queries[310].weight(); } record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -29568,29 +29898,30 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 1;
-const IN_310: usize = 1;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_311: usize = 1;
+const IN_311: usize = 1;
+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_310], ExecError> {
+) -> Result<[G; OUT_311], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
       1u64 => {
-        let __ret: [G; OUT_310] = [__v_0];
-        if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_311] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -29598,21 +29929,21 @@ fn aiur_fn_310(
           _ => {
             match __v_5.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_7: G = __loaded[0];
                 let __v_8: G = __loaded[1];
                 let __v_9: G = __loaded[2];
                 match __v_7.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__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 { let __r = record.function_queries[311].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_310] = [__v_10];
-                    if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_311] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_310] = [__v_0];
-                    if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_311] = [__v_0];
+                    if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29621,8 +29952,8 @@ fn aiur_fn_310(
                 }
               },
               _ => {
-                let __ret: [G; OUT_310] = [__v_0];
-                if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_311] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[311].weight(); } record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -29636,43 +29967,44 @@ fn aiur_fn_310(
   })
 }
 
-const INPUT_SIZE_311: usize = 2;
-const IN_311: usize = 2;
-const OUT_311: usize = 1;
-fn aiur_fn_311(
-  inp: [G; IN_311],
+const INPUT_SIZE_312: usize = 2;
+const IN_312: usize = 2;
+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_311], ExecError> {
+) -> Result<[G; OUT_312], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0]; 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 { let __r = record.function_queries[311].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__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 { let __r = record.function_queries[311].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_311] = [__v_10];
-            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_312] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_311] = [__v_10];
-            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_312] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -29681,51 +30013,51 @@ fn aiur_fn_311(
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_311] = [__v_10];
-            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_312] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_10: G = __loaded[0];
             let __v_11: G = __loaded[1];
             let __v_12: G = __loaded[2];
             match __v_10.as_canonical_u64() {
               _ => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_13: G = __loaded[0];
                 let __v_14: G = __loaded[1];
                 let __v_15: G = __loaded[2];
                 match __v_13.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10, __v_13]; 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 { let __r = record.function_queries[296].replay_at(__i); record.virt += __r; } 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_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_300] = { let __args: [G; IN_300] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_12, __v_15]; 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 { let __r = record.function_queries[301].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
                             match __v_18.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_9]; 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 { let __r = record.function_queries[312].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                                let __ret: [G; OUT_311] = [__v_19];
-                                if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_312] = [__v_19];
+                                if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_19: G = G::from_u64(0);
-                                let __ret: [G; OUT_311] = [__v_19];
-                                if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_312] = [__v_19];
+                                if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -29735,16 +30067,16 @@ fn aiur_fn_311(
                           },
                           _ => {
                             let __v_18: G = G::from_u64(0);
-                            let __ret: [G; OUT_311] = [__v_18];
-                            if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_312] = [__v_18];
+                            if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __ret: [G; OUT_311] = [__v_17];
-                        if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_312] = [__v_17];
+                        if !unconstrained { record.virt += record.function_queries[312].weight(); } record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -29765,45 +30097,46 @@ fn aiur_fn_311(
   })
 }
 
-const INPUT_SIZE_312: usize = 3;
-const IN_312: usize = 3;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+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_312], ExecError> {
+) -> Result<[G; OUT_313], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_312] = [__v_6];
-        if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_313] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_6, __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 { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[313].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                let __ret: [G; OUT_312] = [__v_10];
-                if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_313] = [__v_10];
+                if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -29814,7 +30147,7 @@ fn aiur_fn_312(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_8, __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 { let __r = record.function_queries[314].replay_at(__i); record.virt += __r; } 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];
     break '__mc_0 [__v_11];
   },
@@ -29827,15 +30160,15 @@ fn aiur_fn_312(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_312] = [__v_12];
-                    if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_313] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[313].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-                    let __ret: [G; OUT_312] = [__v_12];
-                    if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_313] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[313].weight(); } record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29854,31 +30187,32 @@ 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_314: usize = 2;
+const IN_314: usize = 2;
+const OUT_314: usize = 1;
+fn aiur_fn_314(
+  inp: [G; IN_314],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], ExecError> {
+) -> Result<[G; OUT_314], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_313] = [__v_5];
-        if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_314] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         match __v_5.as_canonical_u64() {
@@ -29889,15 +30223,15 @@ fn aiur_fn_313(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_313] = [__v_10];
-                if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_314] = [__v_10];
+                if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __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 { let __r = record.function_queries[314].replay_at(__i); record.virt += __r; } 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_313] = [__v_10];
-                if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_314] = [__v_10];
+                if !unconstrained { record.virt += record.function_queries[314].weight(); } record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -29914,63 +30248,64 @@ fn aiur_fn_313(
   })
 }
 
-const INPUT_SIZE_314: usize = 4;
-const IN_314: usize = 4;
-const OUT_314: usize = 1;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+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_314], ExecError> {
+) -> Result<[G; OUT_315], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_314] = [__v_7];
-        if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_315] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_7, __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 { let __r = record.function_queries[297].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __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 { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } 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_314] = [__v_11];
-                if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_315] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __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 { let __r = record.function_queries[316].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_314] = [__v_12];
-                    if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_315] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __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 { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } 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_314] = [__v_12];
-                    if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_315] = [__v_12];
+                    if !unconstrained { record.virt += record.function_queries[315].weight(); } record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29989,32 +30324,33 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 3;
-const IN_315: usize = 3;
-const OUT_315: usize = 1;
-fn aiur_fn_315(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], ExecError> {
+) -> Result<[G; OUT_316], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_315] = [__v_6];
-        if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_316] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
@@ -30026,15 +30362,15 @@ fn aiur_fn_315(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_315] = [__v_10];
-                    if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_316] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[316].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_315] = [__v_10];
-                    if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_316] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30043,10 +30379,10 @@ fn aiur_fn_315(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[316].replay_at(__i); record.virt += __r; } 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_315] = [__v_9];
-                if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_316] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[316].weight(); } record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -30060,31 +30396,32 @@ fn aiur_fn_315(
   })
 }
 
-const INPUT_SIZE_316: usize = 2;
-const IN_316: usize = 2;
-const OUT_316: usize = 1;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_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_316], ExecError> {
+) -> Result<[G; OUT_317], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_316] = [__v_5];
-        if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_317] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -30096,7 +30433,7 @@ fn aiur_fn_316(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_5, __v_6]; 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 { let __r = record.function_queries[313].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -30106,25 +30443,25 @@ fn aiur_fn_316(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_316] = [__v_9];
-                if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_317] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_7, __v_1, __v_5]; 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 { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_316] = [__v_10];
-                    if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_317] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[317].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                    let __ret: [G; OUT_316] = [__v_10];
-                    if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_317] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[317].weight(); } record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30146,50 +30483,51 @@ fn aiur_fn_316(
   })
 }
 
-const INPUT_SIZE_317: usize = 3;
-const IN_317: usize = 3;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+const INPUT_SIZE_318: usize = 3;
+const IN_318: usize = 3;
+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_317], ExecError> {
+) -> Result<[G; OUT_318], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_317] = [__v_6];
-        if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_318] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[318].weight(); } record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
+        let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_1, __v_2, __v_6, __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 { let __r = record.function_queries[315].replay_at(__i); record.virt += __r; } 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];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_317] = [__v_9];
-                if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_318] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[318].weight(); } record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[318].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_317] = [__v_9];
-                if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_318] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[318].weight(); } record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -30206,86 +30544,88 @@ fn aiur_fn_317(
   })
 }
 
-const INPUT_SIZE_318: usize = 1;
-const IN_318: usize = 1;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+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_318], ExecError> {
+) -> Result<[G; OUT_319], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(1);
     let __v_7: G = G::from_u64(1);
-    let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_10: G = G::from_u64(1);
     let __v_11: G = G::from_u64(1);
-    let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_14: G = G::from_u64(1);
     let __v_15: G = G::from_u64(1);
-    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_16, __v_17, __v_13]; 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 { let __r = record.function_queries[307].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_18, __v_18]; 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 { let __r = record.function_queries[309].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-    let __ret: [G; OUT_318] = [__v_19];
-    if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_319] = [__v_19];
+    if !unconstrained { record.virt += record.function_queries[319].weight(); } record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_319: usize = 2;
-const IN_319: usize = 2;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_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],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], ExecError> {
+) -> Result<[G; OUT_320], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_319] = [__v_3];
-        if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_320] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[320].weight(); } record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_319] = [__v_6];
-            if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_320] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[320].weight(); } record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[319].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[319].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_7]; 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 { let __r = record.function_queries[317].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __ret: [G; OUT_319] = [__v_8];
-            if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_320] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[320].weight(); } record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -30297,36 +30637,37 @@ 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_321: usize = 2;
+const IN_321: usize = 2;
+const OUT_321: usize = 1;
+fn aiur_fn_321(
+  inp: [G; IN_321],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], ExecError> {
+) -> Result<[G; OUT_321], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_320] = [__v_3];
-        if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_321] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[319].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[319].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_4]; 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 { let __r = record.function_queries[312].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_320] = [__v_5];
-        if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_321] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[321].weight(); } record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -30336,24 +30677,25 @@ fn aiur_fn_320(
   })
 }
 
-const INPUT_SIZE_321: usize = 2;
-const IN_321: usize = 2;
-const OUT_321: usize = 1;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+const INPUT_SIZE_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_321], ExecError> {
+) -> Result<[G; OUT_322], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -30361,13 +30703,13 @@ fn aiur_fn_321(
             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_321] = [__v_1];
-                if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_322] = [__v_1];
+                if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_321] = [__v_0];
-                if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_322] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -30376,90 +30718,91 @@ fn aiur_fn_321(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __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 { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_321] = [__v_6];
-            if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_322] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __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 { let __r = record.function_queries[323].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __ret: [G; OUT_321] = [__v_4];
-        if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_322] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[322].weight(); } record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_322: usize = 2;
-const IN_322: usize = 2;
-const OUT_322: usize = 1;
-fn aiur_fn_322(
-  inp: [G; IN_322],
+const INPUT_SIZE_323: usize = 2;
+const IN_323: usize = 2;
+const OUT_323: usize = 1;
+fn aiur_fn_323(
+  inp: [G; IN_323],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_322], ExecError> {
+) -> Result<[G; OUT_323], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; 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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_322] = [__v_0];
-        if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_323] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_322] = [__v_1];
-            if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_323] = [__v_1];
+            if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_322] = [__v_0];
-                if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_323] = [__v_0];
+                if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_0]; 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 { let __r = record.function_queries[325].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_322] = [__v_1];
-                    if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_323] = [__v_1];
+                    if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[325].replay_at(__i); record.virt += __r; } 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];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_322] = [__v_0];
-                        if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_323] = [__v_0];
+                        if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[326].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                        let __ret: [G; OUT_322] = [__v_11];
-                        if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_323] = [__v_11];
+                        if !unconstrained { record.virt += record.function_queries[323].weight(); } record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -30483,123 +30826,124 @@ fn aiur_fn_322(
   })
 }
 
-const INPUT_SIZE_323: usize = 2;
-const IN_323: usize = 2;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
+const INPUT_SIZE_324: usize = 2;
+const IN_324: usize = 2;
+const OUT_324: usize = 1;
+fn aiur_fn_324(
+  inp: [G; IN_324],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_323], ExecError> {
+) -> Result<[G; OUT_324], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = (__v_0 - __v_1);
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_323] = [__v_3];
-        if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_324] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           1u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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 __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_323] = [__v_11];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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 __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_323] = [__v_11];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -30609,22 +30953,22 @@ fn aiur_fn_323(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_323] = [__v_10];
-                    if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_324] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_323] = [__v_10];
-                    if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_324] = [__v_10];
+                    if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_323] = [__v_9];
-                if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_324] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[324].weight(); } record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -30638,38 +30982,39 @@ 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_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_324], ExecError> {
+) -> Result<[G; OUT_325], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_1]; 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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_324] = [__v_6];
-            if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_325] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_1]; 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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_324] = [__v_6];
-            if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_325] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -30679,48 +31024,49 @@ fn aiur_fn_324(
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_324] = [__v_5];
-        if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_325] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[325].weight(); } record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+const INPUT_SIZE_326: usize = 2;
+const IN_326: usize = 2;
+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_325], ExecError> {
+) -> Result<[G; OUT_326], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_327] = { let __args: [G; IN_327] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_2]; 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 { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } 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_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_327] = { let __args: [G; IN_327] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_5]; 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 { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_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_325] = [__v_1];
-            if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_326] = [__v_1];
+            if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_325] = [__v_0];
-            if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_326] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -30730,9 +31076,9 @@ fn aiur_fn_325(
       },
       0u64 => {
         let __v_9: G = G::from_u64(2);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_325] = [__v_10];
-        if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_326] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[326].weight(); } record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -30742,18 +31088,19 @@ fn aiur_fn_325(
   })
 }
 
-const INPUT_SIZE_326: usize = 1;
-const IN_326: usize = 1;
-const OUT_326: usize = 2;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_327: usize = 1;
+const IN_327: usize = 1;
+const OUT_327: usize = 2;
+fn aiur_fn_327(
+  inp: [G; IN_327],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], ExecError> {
+) -> Result<[G; OUT_327], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -30761,12 +31108,12 @@ fn aiur_fn_326(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_326] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_327] = [__v_4, __v_5];
+        if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_2]; 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 { let __r = record.function_queries[327].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -30774,15 +31121,15 @@ fn aiur_fn_326(
             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_326] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_327] = [__v_6, __v_8];
+            if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_326] = [__v_6, __v_7];
-            if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_327] = [__v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -30790,27 +31137,28 @@ fn aiur_fn_326(
       _ => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_326] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_327] = [__v_4, __v_5];
+        if !unconstrained { record.virt += record.function_queries[327].weight(); } record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_327: usize = 2;
-const IN_327: usize = 2;
-const OUT_327: usize = 2;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+const INPUT_SIZE_328: usize = 2;
+const IN_328: usize = 2;
+const OUT_328: usize = 2;
+fn aiur_fn_328(
+  inp: [G; IN_328],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_327], ExecError> {
+) -> Result<[G; OUT_328], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -30818,35 +31166,36 @@ fn aiur_fn_327(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_3, __v_6]; 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 { let __r = record.function_queries[328].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_327] = [__v_7, __v_8];
-        if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_328] = [__v_7, __v_8];
+        if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_327] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_328] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[328].weight(); } record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_328: usize = 2;
-const IN_328: usize = 2;
-const OUT_328: usize = 1;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+const INPUT_SIZE_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_328], ExecError> {
+) -> Result<[G; OUT_329], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -30854,54 +31203,54 @@ fn aiur_fn_328(
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_328] = [__v_7];
-        if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_329] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __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 { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_328] = [__v_5];
-        if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_329] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__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 { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0, __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 { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __ret: [G; OUT_328] = [__v_6];
-            if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_329] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_328] = [__v_1];
-                if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_329] = [__v_1];
+                if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __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 { let __r = record.function_queries[295].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_328] = [__v_0];
-                    if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_329] = [__v_0];
+                    if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_10: G = G::from_u64(3);
-                    let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_328] = [__v_11];
-                    if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_329] = [__v_11];
+                    if !unconstrained { record.virt += record.function_queries[329].weight(); } record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30920,18 +31269,19 @@ fn aiur_fn_328(
   })
 }
 
-const INPUT_SIZE_329: usize = 1;
-const IN_329: usize = 1;
-const OUT_329: usize = 1;
-fn aiur_fn_329(
-  inp: [G; IN_329],
+const INPUT_SIZE_330: usize = 1;
+const IN_330: usize = 1;
+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_329], ExecError> {
+) -> Result<[G; OUT_330], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -30939,49 +31289,49 @@ fn aiur_fn_329(
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_329] = [__v_6];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_330] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(4);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_329] = [__v_6];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_330] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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 __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_329] = [__v_7];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_330] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; 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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_5]; 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 { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_329] = [__v_6];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_330] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3]; 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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_5]; 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 { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_329] = [__v_6];
-        if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_330] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[330].weight(); } record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -30991,19 +31341,20 @@ fn aiur_fn_329(
   })
 }
 
-const INPUT_SIZE_330: usize = 2;
-const IN_330: usize = 2;
-const OUT_330: usize = 1;
-fn aiur_fn_330(
-  inp: [G; IN_330],
+const INPUT_SIZE_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_330], ExecError> {
+) -> Result<[G; OUT_331], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -31011,48 +31362,48 @@ fn aiur_fn_330(
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_330] = [__v_7];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_331] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_330] = [__v_8];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_331] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_5, __v_6]; 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 { let __r = record.function_queries[322].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_330] = [__v_7];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_331] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __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 { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_330] = [__v_7];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_331] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_330] = [__v_5];
-        if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_331] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[331].weight(); } record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31062,19 +31413,20 @@ fn aiur_fn_330(
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 1;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_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_331], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -31082,20 +31434,20 @@ fn aiur_fn_331(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_331] = [__v_7];
-        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_332] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[332].weight(); } record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_331] = [__v_8];
-        if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_332] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[332].weight(); } record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31105,52 +31457,54 @@ fn aiur_fn_331(
   })
 }
 
-const INPUT_SIZE_332: usize = 2;
-const IN_332: usize = 2;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+const INPUT_SIZE_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_332], ExecError> {
+) -> Result<[G; OUT_333], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_332] = [__v_0];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_333] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[334].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __ret: [G; OUT_332] = [__v_5];
-        if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_333] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[333].weight(); } record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_333: usize = 2;
-const IN_333: usize = 2;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_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_333], ExecError> {
+) -> Result<[G; OUT_334], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -31159,95 +31513,95 @@ fn aiur_fn_333(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_8];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __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 { let __r = record.function_queries[331].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_9];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[332].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_9];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_10];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_10];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_10];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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];
-        let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_10];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(7);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_8];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_8];
-        if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_334] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[334].weight(); } record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31257,19 +31611,20 @@ 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_335: usize = 2;
+const IN_335: usize = 2;
+const OUT_335: usize = 1;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_334], ExecError> {
+) -> Result<[G; OUT_335], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -31282,7 +31637,7 @@ fn aiur_fn_334(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -31296,20 +31651,20 @@ fn aiur_fn_334(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_334] = [__v_22];
-            if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_335] = [__v_22];
+            if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_334] = [__v_22];
-            if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_335] = [__v_22];
+            if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -31323,25 +31678,25 @@ fn aiur_fn_334(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_334] = [__v_22];
-            if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_335] = [__v_22];
+            if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_12(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } } else { aiur_fn_12(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11, __v_21]; 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 { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                let __ret: [G; OUT_334] = [__v_23];
-                if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_335] = [__v_23];
+                if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_334] = [__v_23];
-                if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_335] = [__v_23];
+                if !unconstrained { record.virt += record.function_queries[335].weight(); } record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -31361,69 +31716,70 @@ 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_336: usize = 2;
+const IN_336: usize = 2;
+const OUT_336: usize = 1;
+fn aiur_fn_336(
+  inp: [G; IN_336],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_335], ExecError> {
+) -> Result<[G; OUT_336], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_335] = [__v_8];
-            if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_336] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_335] = [__v_8];
-            if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_336] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_335] = [__v_8];
-            if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_336] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = (__v_3 - __v_6);
             match __v_8.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __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 { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                let __ret: [G; OUT_335] = [__v_9];
-                if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_336] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_335] = [__v_9];
-                if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_336] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[336].weight(); } record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -31440,16 +31796,17 @@ fn aiur_fn_335(
   })
 }
 
-const INPUT_SIZE_336: usize = 4;
-const IN_336: usize = 4;
-const OUT_336: usize = 1;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+const INPUT_SIZE_337: usize = 4;
+const IN_337: usize = 4;
+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_336], ExecError> {
+) -> Result<[G; OUT_337], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -31458,16 +31815,16 @@ fn aiur_fn_336(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; 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 { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_336] = [__v_4];
-            if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_337] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_336] = [__v_4];
-            if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_337] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -31475,16 +31832,16 @@ fn aiur_fn_336(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_3]; 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 { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-            let __ret: [G; OUT_336] = [__v_4];
-            if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_337] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_336] = [__v_4];
-            if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_337] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[337].weight(); } record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -31496,18 +31853,19 @@ fn aiur_fn_336(
   })
 }
 
-const INPUT_SIZE_337: usize = 1;
-const IN_337: usize = 1;
-const OUT_337: usize = 1;
-fn aiur_fn_337(
-  inp: [G; IN_337],
+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_337], ExecError> {
+) -> Result<[G; OUT_338], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -31516,77 +31874,77 @@ fn aiur_fn_337(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_337] = [__v_6];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_337] = [__v_5];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_337] = [__v_5];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_337] = [__v_5];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_6]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_337] = [__v_7];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } 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_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_337] = [__v_8];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_337] = { let __args: [G; IN_337] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } 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_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __ret: [G; OUT_337] = [__v_8];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[339].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_337] = [__v_5];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_337] = [__v_5];
-        if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_338] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[338].weight(); } record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31596,59 +31954,61 @@ fn aiur_fn_337(
   })
 }
 
-const INPUT_SIZE_338: usize = 3;
-const IN_338: usize = 3;
-const OUT_338: usize = 1;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_339: usize = 3;
+const IN_339: usize = 3;
+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_338], ExecError> {
+) -> Result<[G; OUT_339], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_339] = { let __args: [G; IN_339] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_3, __v_4]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[341].replay_at(__i); record.virt += __r; } 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_339] = { let __args: [G; IN_339] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_5, __v_7]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __ret: [G; OUT_338] = [__v_8];
-    if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_339] = [__v_8];
+    if !unconstrained { record.virt += record.function_queries[339].weight(); } record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-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_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_339], ExecError> {
+) -> Result<[G; OUT_340], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_339] = [__v_1];
-        if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_340] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[340].weight(); } record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_339] = [__v_0];
-        if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_340] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[340].weight(); } record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31658,57 +32018,59 @@ fn aiur_fn_339(
   })
 }
 
-const INPUT_SIZE_340: usize = 1;
-const IN_340: usize = 1;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+const INPUT_SIZE_341: usize = 1;
+const IN_341: usize = 1;
+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_340], ExecError> {
+) -> Result<[G; OUT_341], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_340] = [__v_1];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[341].weight(); } record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = (__v_0 - __v_1);
-        let __ret: [G; OUT_340] = [__v_2];
-        if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_341] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[341].weight(); } record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_341: usize = 2;
-const IN_341: usize = 2;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_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_341], ExecError> {
+) -> Result<[G; OUT_342], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_341] = [__v_0];
-        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_342] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[342].weight(); } record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_341] = [__v_1];
-        if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_342] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[342].weight(); } record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31718,25 +32080,6 @@ fn aiur_fn_341(
   })
 }
 
-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_342], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = { 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 };
-    let __ret: [G; OUT_342] = [__v_2];
-    if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_343: usize = 3;
 const IN_343: usize = 3;
 const OUT_343: usize = 1;
@@ -31747,10 +32090,11 @@ fn aiur_fn_343(
   unconstrained: bool,
 ) -> Result<[G; OUT_343], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -31762,13 +32106,13 @@ fn aiur_fn_343(
           1u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_343] = [__v_8];
-            if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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_343] = [__v_8];
-            if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -31779,36 +32123,36 @@ fn aiur_fn_343(
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_343] = [__v_8];
-            if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_343] = [__v_8];
-            if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -31817,31 +32161,31 @@ fn aiur_fn_343(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[344].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[344].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_6, __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 { let __r = record.function_queries[345].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_343] = [__v_7];
-        if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[343].weight(); } record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31861,17 +32205,18 @@ fn aiur_fn_344(
   unconstrained: bool,
 ) -> Result<[G; OUT_344], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_344] = [__v_5];
-        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[344].weight(); } record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -31879,10 +32224,10 @@ fn aiur_fn_344(
         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_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_6, __v_8]; 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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __ret: [G; OUT_344] = [__v_9];
-        if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[344].weight(); } record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -31902,28 +32247,29 @@ fn aiur_fn_345(
   unconstrained: bool,
 ) -> Result<[G; OUT_345], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __ret: [G; OUT_345] = [__v_6];
-        if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_345] = [__v_7];
-            if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
@@ -31931,10 +32277,10 @@ fn aiur_fn_345(
             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_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_8, __v_10]; 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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_345] = [__v_11];
-            if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[345].weight(); } record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -31959,16 +32305,17 @@ fn aiur_fn_346(
   unconstrained: bool,
 ) -> Result<[G; OUT_346], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __v_2]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3]; 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 { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __ret: [G; OUT_346] = [__v_4];
-    if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[346].weight(); } record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -31983,26 +32330,27 @@ fn aiur_fn_347(
   unconstrained: bool,
 ) -> Result<[G; OUT_347], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; 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 { let __r = record.function_queries[348].replay_at(__i); record.virt += __r; } 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_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_347] = [__v_2];
-        if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[347].weight(); } record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __v_5: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; 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 { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = (__v_2 + __v_6);
         let __ret: [G; OUT_347] = [__v_7];
-        if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[347].weight(); } record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32022,21 +32370,22 @@ fn aiur_fn_348(
   unconstrained: bool,
 ) -> Result<[G; OUT_348], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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(1);
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_3, __v_5]; 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 { let __r = record.function_queries[349].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = (__v_4 + __v_6);
         let __ret: [G; OUT_348] = [__v_7];
-        if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[348].weight(); } record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32056,34 +32405,35 @@ fn aiur_fn_349(
   unconstrained: bool,
 ) -> Result<[G; OUT_349], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_349] = [__v_2];
-        if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0]; 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 { let __r = record.function_queries[348].replay_at(__i); record.virt += __r; } 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_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_349] = [__v_2];
-            if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_2]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
             let __v_5: G = (__v_1 - __v_2);
-            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5]; 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 { let __r = record.function_queries[349].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = (__v_2 + __v_6);
             let __ret: [G; OUT_349] = [__v_7];
-            if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[349].weight(); } record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32105,38 +32455,39 @@ fn aiur_fn_350(
   unconstrained: bool,
 ) -> Result<[G; OUT_350], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_350] = [__v_4];
-        if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_350] = [__v_0];
-            if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1, __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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_5]; 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 { let __r = record.function_queries[347].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_6]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
             let __ret: [G; OUT_350] = [__v_7];
-            if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[350].weight(); } record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32158,26 +32509,27 @@ fn aiur_fn_351(
   unconstrained: bool,
 ) -> Result<[G; OUT_351], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_1 + __v_3);
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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 __v_6: G = G::from_u64(4294967295);
         let __ret: [G; OUT_351] = [__v_6];
-        if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[351].weight(); } record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_1]; 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 { let __r = record.function_queries[352].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_351] = [__v_6];
-        if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[351].weight(); } record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -32194,28 +32546,29 @@ fn aiur_fn_352(
   unconstrained: bool,
 ) -> Result<[G; OUT_352], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; 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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(4294967295);
             let __ret: [G; OUT_352] = [__v_7];
-            if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_7: G = (__v_3 - __v_1);
             let __ret: [G; OUT_352] = [__v_7];
-            if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32226,58 +32579,58 @@ fn aiur_fn_352(
       1u64 => {
         let __v_6: G = G::from_u64(4294967295);
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(4294967295);
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(4294967295);
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_7]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __ret: [G; OUT_352] = [__v_8];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; 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 { let __r = record.function_queries[353].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_4, __v_1]; 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 { let __r = record.function_queries[353].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_4, __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 { let __r = record.function_queries[354].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_352] = [__v_6];
-        if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[352].weight(); } record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32297,19 +32650,20 @@ fn aiur_fn_353(
   unconstrained: bool,
 ) -> Result<[G; OUT_353], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(1);
     let __v_5: G = (__v_2 + __v_4);
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_5]; 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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_3, __v_6]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __ret: [G; OUT_353] = [__v_7];
-    if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[353].weight(); } record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -32324,24 +32678,25 @@ fn aiur_fn_354(
   unconstrained: bool,
 ) -> Result<[G; OUT_354], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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];
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(1);
     let __v_8: G = (__v_3 + __v_7);
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_9]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __ret: [G; OUT_354] = [__v_10];
-    if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[354].weight(); } record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -32356,31 +32711,32 @@ fn aiur_fn_355(
   unconstrained: bool,
 ) -> Result<[G; OUT_355], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_355] = [__v_0];
-        if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_355] = [__v_0];
-            if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[356].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             let __ret: [G; OUT_355] = [__v_5];
-            if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[355].weight(); } record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32402,100 +32758,101 @@ fn aiur_fn_356(
   unconstrained: bool,
 ) -> Result<[G; OUT_356], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[357].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_356] = [__v_7];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_9];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_9];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_11];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_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_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_13];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_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_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_13];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_5, __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 { let __r = record.function_queries[358].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_356] = [__v_7];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_9];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_356] = [__v_9];
-        if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[356].weight(); } record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32515,6 +32872,7 @@ fn aiur_fn_357(
   unconstrained: bool,
 ) -> Result<[G; OUT_357], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -32523,18 +32881,18 @@ fn aiur_fn_357(
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_357] = [__v_6];
-        if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[357].weight(); } record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = (__v_0 + __v_1);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_357] = [__v_7];
-        if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[357].weight(); } record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32554,23 +32912,24 @@ fn aiur_fn_358(
   unconstrained: bool,
 ) -> Result<[G; OUT_358], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_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_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3, __v_9]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_358] = [__v_11];
-    if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[358].weight(); } record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -32585,31 +32944,32 @@ fn aiur_fn_359(
   unconstrained: bool,
 ) -> Result<[G; OUT_359], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_359] = [__v_0];
-        if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_359] = [__v_0];
-            if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __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 { let __r = record.function_queries[360].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             let __ret: [G; OUT_359] = [__v_5];
-            if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[359].weight(); } record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32631,10 +32991,11 @@ fn aiur_fn_360(
   unconstrained: bool,
 ) -> Result<[G; OUT_360], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -32645,16 +33006,16 @@ fn aiur_fn_360(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_360] = [__v_0];
-            if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
             let __v_9: G = (__v_4 - __v_1);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_360] = [__v_11];
-            if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -32665,89 +33026,89 @@ fn aiur_fn_360(
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_9];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_9];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_11];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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 __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_13];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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 __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_13];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_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_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_11]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_13];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_9];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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 __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_360] = [__v_9];
-        if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[360].weight(); } record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -32767,9 +33128,10 @@ fn aiur_fn_361(
   unconstrained: bool,
 ) -> Result<[G; OUT_361], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -32781,68 +33143,68 @@ fn aiur_fn_361(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_361] = [__v_7];
-            if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
             let __ret: [G; OUT_361] = [__v_7];
-            if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_361] = [__v_7];
-            if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_361] = [__v_7];
-            if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __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 { let __r = record.function_queries[362].replay_at(__i); record.virt += __r; } 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_361] = [__v_6];
-        if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __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 { let __r = record.function_queries[362].replay_at(__i); record.virt += __r; } 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_361] = [__v_6];
-        if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_4, __v_5, __v_1]; 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 { let __r = record.function_queries[363].replay_at(__i); record.virt += __r; } 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_361] = [__v_6];
-        if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_5, __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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_361] = [__v_6];
-        if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_361] = [__v_6];
-        if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[361].weight(); } record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -32859,25 +33221,26 @@ fn aiur_fn_362(
   unconstrained: bool,
 ) -> Result<[G; OUT_362], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_362] = [__v_4];
-        if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[362].weight(); } record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_2 + __v_4);
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_5]; 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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_362] = [__v_6];
-        if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[362].weight(); } record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -32894,36 +33257,37 @@ fn aiur_fn_363(
   unconstrained: bool,
 ) -> Result<[G; OUT_363], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_3]; 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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_363] = [__v_5];
-        if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_1, __v_3]; 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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
             let __ret: [G; OUT_363] = [__v_6];
-            if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_3 + __v_6);
-            let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_2, __v_7]; 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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_363] = [__v_8];
-            if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[363].weight(); } record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -32942,38 +33306,39 @@ fn aiur_fn_364(
   unconstrained: bool,
 ) -> Result<[G; OUT_364], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_364] = [__v_0];
-        if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __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 { let __r = record.function_queries[361].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __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 { let __r = record.function_queries[365].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __ret: [G; OUT_364] = [__v_6];
-            if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_8]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_364] = [__v_9];
-            if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[364].weight(); } record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -32995,100 +33360,101 @@ fn aiur_fn_365(
   unconstrained: bool,
 ) -> Result<[G; OUT_365], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __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 { let __r = record.function_queries[366].replay_at(__i); record.virt += __r; } 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_365] = [__v_7];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_9];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_9];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_11];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_13];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_13];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_5, __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 { let __r = record.function_queries[367].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_365] = [__v_7];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_9];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_365] = [__v_9];
-        if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[365].weight(); } record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -33108,18 +33474,19 @@ fn aiur_fn_366(
   unconstrained: bool,
 ) -> Result<[G; OUT_366], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; 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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_366] = [__v_6];
-        if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -33127,10 +33494,10 @@ fn aiur_fn_366(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2, __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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_366] = [__v_6];
-            if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -33138,9 +33505,9 @@ fn aiur_fn_366(
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_0 - __v_6);
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_366] = [__v_9];
-            if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[366].weight(); } record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -33162,23 +33529,24 @@ fn aiur_fn_367(
   unconstrained: bool,
 ) -> Result<[G; OUT_367], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_3, __v_9]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_367] = [__v_11];
-    if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[367].weight(); } record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33193,46 +33561,47 @@ fn aiur_fn_368(
   unconstrained: bool,
 ) -> Result<[G; OUT_368], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_368] = [__v_0];
-        if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_342] = { let __args: [G; IN_342] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_368] = [__v_0];
-            if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = (__v_2 + __v_3);
-            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_2, __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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __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 { let __r = record.function_queries[370].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 let __ret: [G; OUT_368] = [__v_8];
-                if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_8: G = (__v_2 + __v_3);
-                let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_8]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 let __ret: [G; OUT_368] = [__v_9];
-                if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[368].weight(); } record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -33256,32 +33625,33 @@ fn aiur_fn_369(
   unconstrained: bool,
 ) -> Result<[G; OUT_369], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
     let __v_4: G = (__v_0 - __v_2);
-    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_4]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_2, __v_7]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __ret: [G; OUT_369] = [__v_8];
-        if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[369].weight(); } record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = (__v_0 - __v_3);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_369] = [__v_9];
-        if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[369].weight(); } record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -33301,100 +33671,101 @@ fn aiur_fn_370(
   unconstrained: bool,
 ) -> Result<[G; OUT_370], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[369].replay_at(__i); record.virt += __r; } 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_370] = [__v_7];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_9];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_9];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_11];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_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_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_13];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_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_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_13];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __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 { let __r = record.function_queries[371].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_370] = [__v_7];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_9];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_370] = [__v_9];
-        if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[370].weight(); } record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -33414,23 +33785,24 @@ fn aiur_fn_371(
   unconstrained: bool,
 ) -> Result<[G; OUT_371], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_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_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_371] = [__v_11];
-    if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[371].weight(); } record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33445,35 +33817,36 @@ fn aiur_fn_372(
   unconstrained: bool,
 ) -> Result<[G; OUT_372], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_9, __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 { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } 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 = __r_arr[1];
             let __v_14: G = __r_arr[2];
             let __ret: [G; OUT_372] = [__v_12, __v_13, __v_14];
-            if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1];
-            if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -33483,7 +33856,7 @@ fn aiur_fn_372(
       },
       _ => {
         let __ret: [G; OUT_372] = [__v_0, __v_2, __v_1];
-        if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[372].weight(); } record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -33500,47 +33873,48 @@ fn aiur_fn_373(
   unconstrained: bool,
 ) -> Result<[G; OUT_373], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; 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 { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_373] = [__v_10];
-        if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_13, __v_8, __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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __ret: [G; OUT_373] = [__v_14];
-        if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_11, __v_8, __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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __ret: [G; OUT_373] = [__v_12];
-        if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[373].weight(); } record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -33557,63 +33931,64 @@ fn aiur_fn_374(
   unconstrained: bool,
 ) -> Result<[G; OUT_374], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_7, __v_9, __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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __ret: [G; OUT_374] = [__v_10];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_1, __v_0, __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 { let __r = record.function_queries[373].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_374] = [__v_7];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5, __v_0, __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 { let __r = record.function_queries[393].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_374] = [__v_7];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_8, __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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __ret: [G; OUT_374] = [__v_9];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[375].replay_at(__i); record.virt += __r; } 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_374] = [__v_7];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_374] = [__v_7];
-        if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[374].weight(); } record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -33630,40 +34005,41 @@ fn aiur_fn_375(
   unconstrained: bool,
 ) -> Result<[G; OUT_375], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_414] = { let __args: [G; IN_414] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; 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 { let __r = record.function_queries[382].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[1];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_10, __v_3, __v_4]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __ret: [G; OUT_375] = [__v_11];
-        if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; 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 { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_17: G = __loaded[1];
             let __v_18: G = __loaded[2];
@@ -33679,32 +34055,32 @@ fn aiur_fn_375(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_29, __v_3, __v_4]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
                 let __ret: [G; OUT_375] = [__v_30];
-                if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
                 let __ret: [G; OUT_375] = [__v_30];
-                if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_15: G = G::from_u64(8);
-            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_375] = [__v_17];
-            if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[375].weight(); } record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -33723,6 +34099,7 @@ fn aiur_fn_376(
   unconstrained: bool,
 ) -> Result<[G; OUT_376], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(116);
     let __v_1: G = G::from_u64(89);
     let __v_2: G = G::from_u64(54);
@@ -33755,9 +34132,9 @@ fn aiur_fn_376(
     let __v_29: G = G::from_u64(86);
     let __v_30: G = G::from_u64(91);
     let __v_31: G = G::from_u64(151);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_376] = [__v_32];
-    if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[376].weight(); } record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33772,6 +34149,7 @@ fn aiur_fn_377(
   unconstrained: bool,
 ) -> Result<[G; OUT_377], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(171);
     let __v_1: G = G::from_u64(55);
     let __v_2: G = G::from_u64(118);
@@ -33804,9 +34182,9 @@ fn aiur_fn_377(
     let __v_29: G = G::from_u64(179);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(25);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_377] = [__v_32];
-    if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[377].weight(); } record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33821,6 +34199,7 @@ fn aiur_fn_378(
   unconstrained: bool,
 ) -> Result<[G; OUT_378], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(57);
     let __v_1: G = G::from_u64(138);
     let __v_2: G = G::from_u64(119);
@@ -33853,9 +34232,9 @@ fn aiur_fn_378(
     let __v_29: G = G::from_u64(242);
     let __v_30: G = G::from_u64(182);
     let __v_31: G = G::from_u64(49);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_378] = [__v_32];
-    if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[378].weight(); } record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33870,6 +34249,7 @@ fn aiur_fn_379(
   unconstrained: bool,
 ) -> Result<[G; OUT_379], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(136);
     let __v_1: G = G::from_u64(38);
     let __v_2: G = G::from_u64(102);
@@ -33902,9 +34282,9 @@ fn aiur_fn_379(
     let __v_29: G = G::from_u64(125);
     let __v_30: G = G::from_u64(236);
     let __v_31: G = G::from_u64(246);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_379] = [__v_32];
-    if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[379].weight(); } record.function_queries[379].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33919,6 +34299,7 @@ fn aiur_fn_380(
   unconstrained: bool,
 ) -> Result<[G; OUT_380], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(141);
     let __v_1: G = G::from_u64(196);
     let __v_2: G = G::from_u64(169);
@@ -33951,9 +34332,9 @@ fn aiur_fn_380(
     let __v_29: G = G::from_u64(139);
     let __v_30: G = G::from_u64(123);
     let __v_31: G = G::from_u64(208);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_380] = [__v_32];
-    if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[380].weight(); } record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -33968,6 +34349,7 @@ fn aiur_fn_381(
   unconstrained: bool,
 ) -> Result<[G; OUT_381], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(18);
     let __v_1: G = G::from_u64(73);
     let __v_2: G = G::from_u64(132);
@@ -34000,9 +34382,9 @@ fn aiur_fn_381(
     let __v_29: G = G::from_u64(176);
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(22);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_381] = [__v_32];
-    if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[381].weight(); } record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -34017,13 +34399,14 @@ fn aiur_fn_382(
   unconstrained: bool,
 ) -> Result<[G; OUT_382], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_376] = { let __args: [G; IN_376] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = []; 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 { let __r = record.function_queries[376].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
     match __v_5.as_canonical_u64() {
       0u64 => {
@@ -34031,24 +34414,24 @@ fn aiur_fn_382(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_382] = [__v_6, __v_10];
-        if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
             let __v_9: G = __loaded[3];
             match __v_6.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = []; 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 { let __r = record.function_queries[377].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
                   0u64 => {
@@ -34056,13 +34439,13 @@ fn aiur_fn_382(
                     let __v_13: G = G::from_u64(0);
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(0);
-                    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_382] = [__v_12, __v_16];
-                    if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -34072,35 +34455,35 @@ fn aiur_fn_382(
                         let __v_16: G = G::from_u64(0);
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
-                        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_382] = [__v_15, __v_19];
-                        if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_15]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
                         let __v_17: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_17]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_18: G = __r_arr[0];
                         let __v_19: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_19]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_20: G = __r_arr[0];
                         let __v_21: G = G::from_u64(3);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_21]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
                         let __v_23: G = G::from_u64(4);
-                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_23]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
-                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                         let __v_26: G = __loaded[1];
                         let __v_27: G = __loaded[2];
                         let __v_28: G = __loaded[3];
                         match __v_25.as_canonical_u64() {
                           4u64 => {
-                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                             let __v_29: G = __loaded[0];
                             let __v_30: G = __loaded[1];
                             let __v_31: G = __loaded[2];
@@ -34108,11 +34491,11 @@ fn aiur_fn_382(
                             match __v_29.as_canonical_u64() {
                               4u64 => {
                                 let __v_33: G = G::from_u64(8);
-                                let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __v_35: G = G::from_u64(4);
                                 let __v_36: G = G::from_u64(0);
-                                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                                let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                 let __v_38: G = __loaded[0];
                                 let __v_39: G = __loaded[1];
                                 let __v_40: G = __loaded[2];
@@ -34120,47 +34503,47 @@ fn aiur_fn_382(
                                 match __v_38.as_canonical_u64() {
                                   4u64 => {
                                     let __v_42: G = G::from_u64(8);
-                                    let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_44: G = G::from_u64(4);
                                     let __v_45: G = G::from_u64(0);
-                                    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_47: G = G::from_u64(2);
-                                    let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; 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 { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
                                     let __v_49: G = G::from_u64(1);
                                     let __v_50: G = G::from_u64(1);
-                                    let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_52: G = G::from_u64(0);
-                                    let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_54: G = G::from_u64(4);
                                     let __v_55: G = G::from_u64(0);
-                                    let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_57: G = G::from_u64(2);
                                     let __v_58: G = G::from_u64(0);
-                                    let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_60: G = G::from_u64(3);
                                     let __v_61: G = G::from_u64(0);
-                                    let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_63: G = G::from_u64(3);
                                     let __v_64: G = G::from_u64(0);
-                                    let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_66: G = G::from_u64(3);
                                     let __v_67: G = G::from_u64(0);
-                                    let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_69: G = G::from_u64(3);
                                     let __v_70: G = G::from_u64(0);
-                                    let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_72: G = G::from_u64(3);
                                     let __v_73: G = G::from_u64(0);
-                                    let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_75: G = G::from_u64(5);
-                                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_75]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_76: G = __r_arr[0];
                                     let __v_77: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_74, __v_76]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
                                     let __ret: [G; OUT_382] = [__v_77, __v_78];
-                                    if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -34168,9 +34551,9 @@ fn aiur_fn_382(
                                     let __v_43: G = G::from_u64(0);
                                     let __v_44: G = G::from_u64(0);
                                     let __v_45: G = G::from_u64(0);
-                                    let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_382] = [__v_42, __v_46];
-                                    if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -34180,9 +34563,9 @@ fn aiur_fn_382(
                                 let __v_34: G = G::from_u64(0);
                                 let __v_35: G = G::from_u64(0);
                                 let __v_36: G = G::from_u64(0);
-                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_382] = [__v_33, __v_37];
-                                if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -34192,9 +34575,9 @@ fn aiur_fn_382(
                             let __v_30: G = G::from_u64(0);
                             let __v_31: G = G::from_u64(0);
                             let __v_32: G = G::from_u64(0);
-                            let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_382] = [__v_29, __v_33];
-                            if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -34208,9 +34591,9 @@ fn aiur_fn_382(
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_382] = [__v_10, __v_14];
-                if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -34220,9 +34603,9 @@ fn aiur_fn_382(
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
-            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_382] = [__v_6, __v_10];
-            if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[382].weight(); } record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -34241,18 +34624,19 @@ fn aiur_fn_383(
   unconstrained: bool,
 ) -> Result<[G; OUT_383], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __ret: [G; OUT_383] = [__v_5];
-        if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[383].weight(); } record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -34261,14 +34645,14 @@ fn aiur_fn_383(
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_383] = [__v_15];
-        if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[383].weight(); } record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -34285,9 +34669,10 @@ fn aiur_fn_384(
   unconstrained: bool,
 ) -> Result<[G; OUT_384], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -34295,20 +34680,20 @@ fn aiur_fn_384(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_384] = [__v_7];
-        if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[384].weight(); } record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_1]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_384] = [__v_8];
-        if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[384].weight(); } record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -34328,20 +34713,21 @@ fn aiur_fn_385(
   unconstrained: bool,
 ) -> Result<[G; OUT_385], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_1, __v_2]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34353,32 +34739,32 @@ fn aiur_fn_385(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_385] = [__v_11, __v_15];
-            if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_18]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                 let __ret: [G; OUT_385] = [__v_17, __v_20];
-                if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -34386,9 +34772,9 @@ fn aiur_fn_385(
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_385] = [__v_15, __v_19];
-                if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -34406,34 +34792,34 @@ fn aiur_fn_385(
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
-                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_385] = [__v_11, __v_15];
-                if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_11]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_12]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3, __v_15]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
                     let __v_17: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_18]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_19]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_385] = [__v_17, __v_21];
-                    if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -34441,9 +34827,9 @@ fn aiur_fn_385(
                     let __v_16: G = G::from_u64(0);
                     let __v_17: G = G::from_u64(0);
                     let __v_18: G = G::from_u64(0);
-                    let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_385] = [__v_15, __v_19];
-                    if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -34451,11 +34837,11 @@ fn aiur_fn_385(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[261].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_385] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[385].weight(); } record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -34474,47 +34860,48 @@ fn aiur_fn_386(
   unconstrained: bool,
 ) -> Result<[G; OUT_386], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_1]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_386] = [__v_2];
-        if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_386] = [__v_2];
-            if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_1]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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 __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_386] = [__v_17];
-            if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[386].weight(); } record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -34539,10 +34926,11 @@ fn aiur_fn_387(
   unconstrained: bool,
 ) -> Result<[G; OUT_387], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
@@ -34550,9 +34938,9 @@ fn aiur_fn_387(
     break '__mc_0 [__v_3];
   },
   _ => {
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34560,9 +34948,9 @@ fn aiur_fn_387(
         break '__mc_0 [__v_5];
       },
       _ => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34570,9 +34958,9 @@ fn aiur_fn_387(
             break '__mc_0 [__v_7];
           },
           _ => {
-            let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34580,9 +34968,9 @@ fn aiur_fn_387(
                 break '__mc_0 [__v_9];
               },
               _ => {
-                let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34590,9 +34978,9 @@ fn aiur_fn_387(
                     break '__mc_0 [__v_11];
                   },
                   _ => {
-                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34600,9 +34988,9 @@ fn aiur_fn_387(
                         break '__mc_0 [__v_13];
                       },
                       _ => {
-                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34610,9 +34998,9 @@ fn aiur_fn_387(
                             break '__mc_0 [__v_15];
                           },
                           _ => {
-                            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[162].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34620,9 +35008,9 @@ fn aiur_fn_387(
                                 break '__mc_0 [__v_17];
                               },
                               _ => {
-                                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34630,9 +35018,9 @@ fn aiur_fn_387(
                                     break '__mc_0 [__v_19];
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34640,9 +35028,9 @@ fn aiur_fn_387(
                                         break '__mc_0 [__v_21];
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[172].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34650,9 +35038,9 @@ fn aiur_fn_387(
                                             break '__mc_0 [__v_23];
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34660,9 +35048,9 @@ fn aiur_fn_387(
                                                 break '__mc_0 [__v_25];
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34670,9 +35058,9 @@ fn aiur_fn_387(
                                                     break '__mc_0 [__v_27];
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34680,9 +35068,9 @@ fn aiur_fn_387(
                                                         break '__mc_0 [__v_29];
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34690,9 +35078,9 @@ fn aiur_fn_387(
                                                             break '__mc_0 [__v_31];
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                                                            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 => {
@@ -34740,63 +35128,63 @@ fn aiur_fn_387(
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_387] = [__v_4];
-        if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; 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 { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(2);
             let __ret: [G; OUT_387] = [__v_5];
-            if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_0]; 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 { let __r = record.function_queries[194].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             match __v_5.as_canonical_u64() {
               1u64 => {
                 let __v_6: G = G::from_u64(3);
                 let __ret: [G; OUT_387] = [__v_6];
-                if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0]; 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 { let __r = record.function_queries[181].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
                 match __v_6.as_canonical_u64() {
                   1u64 => {
                     let __v_7: G = G::from_u64(4);
                     let __ret: [G; OUT_387] = [__v_7];
-                    if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0]; 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 { let __r = record.function_queries[511].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
                     match __v_7.as_canonical_u64() {
                       1u64 => {
                         let __v_8: G = G::from_u64(5);
                         let __ret: [G; OUT_387] = [__v_8];
-                        if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; 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 { let __r = record.function_queries[239].replay_at(__i); record.virt += __r; } 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];
                         match __v_8.as_canonical_u64() {
                           1u64 => {
                             let __v_9: G = G::from_u64(6);
                             let __ret: [G; OUT_387] = [__v_9];
-                            if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_9: G = G::from_u64(0);
                             let __ret: [G; OUT_387] = [__v_9];
-                            if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[387].weight(); } record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -34823,61 +35211,62 @@ fn aiur_fn_388(
   unconstrained: bool,
 ) -> Result<[G; OUT_388], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 { let __r = record.function_queries[387].replay_at(__i); record.virt += __r; } 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];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[385].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_2, __v_3]; 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 { let __r = record.function_queries[384].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_5, __v_3]; 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 { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_6, __v_7];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[517].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_388] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -34885,9 +35274,9 @@ fn aiur_fn_388(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_388] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[388].weight(); } record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -34904,34 +35293,35 @@ fn aiur_fn_389(
   unconstrained: bool,
 ) -> Result<[G; OUT_389], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[380].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; 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 { let __r = record.function_queries[390].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __ret: [G; OUT_389] = [__v_5, __v_6];
-        if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[381].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_1, __v_2]; 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 { let __r = record.function_queries[391].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             let __ret: [G; OUT_389] = [__v_7, __v_8];
-            if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -34939,9 +35329,9 @@ fn aiur_fn_389(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_389] = [__v_7, __v_11];
-            if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[389].weight(); } record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -34960,9 +35350,10 @@ fn aiur_fn_390(
   unconstrained: bool,
 ) -> Result<[G; OUT_390], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -34972,34 +35363,34 @@ fn aiur_fn_390(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_390] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __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 { let __r = record.function_queries[392].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_390] = [__v_13, __v_17];
-            if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -35007,9 +35398,9 @@ fn aiur_fn_390(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_390] = [__v_11, __v_15];
-            if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[390].weight(); } record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35028,9 +35419,10 @@ fn aiur_fn_391(
   unconstrained: bool,
 ) -> Result<[G; OUT_391], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -35040,34 +35432,34 @@ fn aiur_fn_391(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_391] = [__v_5, __v_9];
-        if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_5]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_7]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_8, __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 { let __r = record.function_queries[392].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_11]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = G::from_u64(3);
             let __v_15: G = G::from_u64(0);
-            let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_12]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_391] = [__v_13, __v_17];
-            if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -35075,9 +35467,9 @@ fn aiur_fn_391(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_391] = [__v_11, __v_15];
-            if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[391].weight(); } record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35096,27 +35488,28 @@ fn aiur_fn_392(
   unconstrained: bool,
 ) -> Result<[G; OUT_392], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[379].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(3);
             let __v_13: G = (__v_11 - __v_12);
@@ -35124,10 +35517,10 @@ fn aiur_fn_392(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(2);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_15]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_16: G = __r_arr[0];
                 let __ret: [G; OUT_392] = [__v_14, __v_16];
-                if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -35135,9 +35528,9 @@ fn aiur_fn_392(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_392] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -35147,9 +35540,9 @@ fn aiur_fn_392(
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_392] = [__v_11, __v_15];
-            if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35159,9 +35552,9 @@ fn aiur_fn_392(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_392] = [__v_9, __v_13];
-        if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[392].weight(); } record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35178,31 +35571,32 @@ fn aiur_fn_393(
   unconstrained: bool,
 ) -> Result<[G; OUT_393], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_393] = [__v_7];
-        if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __ret: [G; OUT_393] = [__v_6];
-        if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -35217,52 +35611,52 @@ fn aiur_fn_393(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_11, __v_3]; 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 { let __r = record.function_queries[394].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             match __v_20.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
                 let __ret: [G; OUT_393] = [__v_22];
-                if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_3, __v_4]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_393] = [__v_23];
-                if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __ret: [G; OUT_393] = [__v_20];
-            if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[389].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             match __v_20.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_21, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
                 let __ret: [G; OUT_393] = [__v_22];
-                if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
                 let __ret: [G; OUT_393] = [__v_22];
-                if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -35273,10 +35667,10 @@ fn aiur_fn_393(
             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_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_10, __v_22]; 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 { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
     let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__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[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[397].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
     let __v_26: G = __r_arr[1];
     break '__mc_0 [__v_25, __v_26];
@@ -35292,45 +35686,45 @@ fn aiur_fn_393(
             match __v_23.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_393] = [__v_24];
-                if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_10, __v_11, __v_13, __v_14, __v_12]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
-                let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__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[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
                 match __v_26.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_27, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
                     let __ret: [G; OUT_393] = [__v_28];
-                    if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   2u64 => {
                     match __v_16.as_canonical_u64() {
                       1u64 => {
                         let __ret: [G; OUT_393] = [__v_27];
-                        if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[404].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
                         let __v_29: G = __r_arr[1];
                         match __v_28.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
                             let __ret: [G; OUT_393] = [__v_30];
-                            if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __ret: [G; OUT_393] = [__v_27];
-                            if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -35338,10 +35732,10 @@ fn aiur_fn_393(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_393] = [__v_28];
-                    if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -35349,10 +35743,10 @@ fn aiur_fn_393(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __ret: [G; OUT_393] = [__v_20];
-            if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[393].weight(); } record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35371,10 +35765,11 @@ fn aiur_fn_394(
   unconstrained: bool,
 ) -> Result<[G; OUT_394], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; 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 { let __r = record.function_queries[395].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -35382,7 +35777,7 @@ fn aiur_fn_394(
     let __v_7: G = __r_arr[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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() {
@@ -35391,23 +35786,23 @@ fn aiur_fn_394(
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_394] = [__v_10, __v_14];
-            if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(8);
-            let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_4]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_12, __v_13]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __ret: [G; OUT_394] = [__v_14, __v_15];
-            if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35417,9 +35812,9 @@ fn aiur_fn_394(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_394] = [__v_8, __v_12];
-        if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[394].weight(); } record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35436,9 +35831,10 @@ fn aiur_fn_395(
   unconstrained: bool,
 ) -> Result<[G; OUT_395], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -35447,18 +35843,18 @@ fn aiur_fn_395(
       4u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_4, __v_7]; 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 { let __r = record.function_queries[395].replay_at(__i); record.virt += __r; } 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_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_395] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -35473,7 +35869,7 @@ fn aiur_fn_395(
                 let __v_13: G = (__v_1 - __v_12);
                 let __v_14: G = (__v_13 - __v_7);
                 let __ret: [G; OUT_395] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -35511,11 +35907,11 @@ fn aiur_fn_395(
                 let __v_42: G = G::from_u64(0);
                 let __v_43: G = G::from_u64(0);
                 let __v_44: G = G::from_u64(0);
-                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_46: G = G::from_u64(0);
                 let __v_47: G = G::from_u64(0);
                 let __ret: [G; OUT_395] = [__v_11, __v_12, __v_45, __v_46, __v_47];
-                if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -35555,11 +35951,11 @@ fn aiur_fn_395(
             let __v_41: G = G::from_u64(0);
             let __v_42: G = G::from_u64(0);
             let __v_43: G = G::from_u64(0);
-            let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_45: G = G::from_u64(0);
             let __v_46: G = G::from_u64(0);
             let __ret: [G; OUT_395] = [__v_10, __v_11, __v_44, __v_45, __v_46];
-            if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -35599,11 +35995,11 @@ fn aiur_fn_395(
         let __v_37: G = G::from_u64(0);
         let __v_38: G = G::from_u64(0);
         let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
         let __ret: [G; OUT_395] = [__v_6, __v_7, __v_40, __v_41, __v_42];
-        if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[395].weight(); } record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35620,8 +36016,9 @@ fn aiur_fn_396(
   unconstrained: bool,
 ) -> Result<[G; OUT_396], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -35630,58 +36027,58 @@ fn aiur_fn_396(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_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_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; 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 { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(1);
                 let __v_9: G = G::from_u64(1);
-                let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_11: G = G::from_u64(0);
-                let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_396] = [__v_12];
-                if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_6]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_12: G = G::from_u64(2);
-                let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_19: G = G::from_u64(3);
                 let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_396] = [__v_21];
-                if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __ret: [G; OUT_396] = [__v_0];
-            if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __ret: [G; OUT_396] = [__v_0];
-        if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[396].weight(); } record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35698,6 +36095,7 @@ fn aiur_fn_397(
   unconstrained: bool,
 ) -> Result<[G; OUT_397], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -35707,7 +36105,7 @@ fn aiur_fn_397(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -35720,9 +36118,9 @@ fn aiur_fn_397(
             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_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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];
             match __v_18.as_canonical_u64() {
               0u64 => {
@@ -35730,15 +36128,15 @@ fn aiur_fn_397(
                 let __v_20: G = G::from_u64(0);
                 let __v_21: G = G::from_u64(0);
                 let __v_22: G = G::from_u64(0);
-                let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_397] = [__v_19, __v_23];
-                if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_16]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_19, __v_10, __v_2, __v_7, __v_8]; 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 { let __r = record.function_queries[398].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                 match __v_20.as_canonical_u64() {
                   0u64 => {
@@ -35746,31 +36144,31 @@ fn aiur_fn_397(
                     let __v_22: G = G::from_u64(0);
                     let __v_23: G = G::from_u64(0);
                     let __v_24: G = G::from_u64(0);
-                    let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_397] = [__v_21, __v_25];
-                    if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_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_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_23]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __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_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_26]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_24]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_28, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
                     let __v_30: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_29, __v_8]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
                     let __ret: [G; OUT_397] = [__v_30, __v_31];
-                    if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -35784,9 +36182,9 @@ fn aiur_fn_397(
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_397] = [__v_14, __v_18];
-        if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[397].weight(); } record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35803,38 +36201,39 @@ fn aiur_fn_398(
   unconstrained: bool,
 ) -> Result<[G; OUT_398], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_4]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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() {
           0u64 => {
             let __v_14: G = G::from_u64(0);
             let __ret: [G; OUT_398] = [__v_14];
-            if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
@@ -35849,27 +36248,27 @@ fn aiur_fn_398(
             let __v_26: G = __loaded[11];
             match __v_15.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_1]; 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 { let __r = record.function_queries[551].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
                 let __v_28: G = G::from_u64(2);
                 let __v_29: G = G::from_u64(0);
-                let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_2]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_31: G = __r_arr[0];
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_30, __v_31]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
-                let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_32, __v_4]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_33, __v_4]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
                 let __ret: [G; OUT_398] = [__v_34];
-                if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_27: G = G::from_u64(0);
                 let __ret: [G; OUT_398] = [__v_27];
-                if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -35879,7 +36278,7 @@ fn aiur_fn_398(
       _ => {
         let __v_13: G = G::from_u64(0);
         let __ret: [G; OUT_398] = [__v_13];
-        if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[398].weight(); } record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35896,26 +36295,27 @@ fn aiur_fn_399(
   unconstrained: bool,
 ) -> Result<[G; OUT_399], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __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_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_5]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(1);
     let __v_9: G = G::from_u64(1);
-    let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_3, __v_11]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_6]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
     let __ret: [G; OUT_399] = [__v_13];
-    if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[399].weight(); } record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -35930,23 +36330,24 @@ fn aiur_fn_400(
   unconstrained: bool,
 ) -> Result<[G; OUT_400], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -35961,26 +36362,26 @@ fn aiur_fn_400(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_13, __v_7]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_22, __v_4, __v_1]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_23, __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 { let __r = record.function_queries[400].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
             let __ret: [G; OUT_400] = [__v_24];
-            if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_400] = [__v_2];
-            if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __ret: [G; OUT_400] = [__v_2];
-        if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[400].weight(); } record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -35997,6 +36398,7 @@ fn aiur_fn_401(
   unconstrained: bool,
 ) -> Result<[G; OUT_401], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -36010,7 +36412,7 @@ fn aiur_fn_401(
     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_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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() {
@@ -36019,45 +36421,45 @@ fn aiur_fn_401(
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
-        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_401] = [__v_15, __v_19];
-        if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_1, __v_2, __v_3, __v_4, __v_12]; 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 { let __r = record.function_queries[259].replay_at(__i); record.virt += __r; } 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_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_401] = [__v_17, __v_16];
-            if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_12]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_17]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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];
-            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_18, __v_7]; 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 { let __r = record.function_queries[400].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_19]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_20]; 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 { let __r = record.function_queries[396].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_21]; 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 { let __r = record.function_queries[402].replay_at(__i); record.virt += __r; } 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_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];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_23]; 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 { let __r = record.function_queries[403].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
                 let __v_28: G = __r_arr[2];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_29: G = __r_arr[0];
                 let __v_30: G = G::from_u64(1);
                 if (__v_29 != __v_30) {
@@ -36065,40 +36467,40 @@ fn aiur_fn_401(
                 }
                 match __v_26.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; 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 { let __r = record.function_queries[399].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
                     let __v_32: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_31]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
                     let __ret: [G; OUT_401] = [__v_32, __v_33];
-                    if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_28, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_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_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1, __v_33]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_25]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_35: G = __r_arr[0];
                     let __v_36: G = (__v_35 - __v_27);
-                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_25, __v_36]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __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_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_39]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_31, __v_34]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_37]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_42, __v_40]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
                     let __v_44: G = G::from_u64(1);
                     let __ret: [G; OUT_401] = [__v_44, __v_43];
-                    if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -36107,13 +36509,13 @@ fn aiur_fn_401(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_12, __v_19]; 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 { let __r = record.function_queries[399].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
                 let __v_27: G = G::from_u64(2);
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_26]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_401] = [__v_27, __v_28];
-                if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[401].weight(); } record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -36134,20 +36536,21 @@ fn aiur_fn_402(
   unconstrained: bool,
 ) -> Result<[G; OUT_402], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -36163,10 +36566,10 @@ fn aiur_fn_402(
         match __v_8.as_canonical_u64() {
           6u64 => {
             let __v_20: G = G::from_u64(1);
-            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_11, __v_12]; 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 { let __r = record.function_queries[460].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
             let __ret: [G; OUT_402] = [__v_20, __v_13, __v_21, __v_2];
-            if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -36204,12 +36607,12 @@ fn aiur_fn_402(
             let __v_51: G = G::from_u64(0);
             let __v_52: G = G::from_u64(0);
             let __v_53: G = G::from_u64(0);
-            let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_55: G = G::from_u64(1);
             let __v_56: G = G::from_u64(1);
-            let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_402] = [__v_20, __v_21, __v_54, __v_57];
-            if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -36249,12 +36652,12 @@ fn aiur_fn_402(
         let __v_38: G = G::from_u64(0);
         let __v_39: G = G::from_u64(0);
         let __v_40: G = G::from_u64(0);
-        let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_42: G = G::from_u64(1);
         let __v_43: G = G::from_u64(1);
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_402] = [__v_7, __v_8, __v_41, __v_44];
-        if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[402].weight(); } record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -36271,9 +36674,10 @@ fn aiur_fn_403(
   unconstrained: bool,
 ) -> Result<[G; OUT_403], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -36286,9 +36690,9 @@ fn aiur_fn_403(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_403] = [__v_7, __v_8, __v_12];
-        if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -36299,16 +36703,16 @@ fn aiur_fn_403(
               0u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_403] = [__v_8, __v_4, __v_5];
-                if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_6, __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 { let __r = record.function_queries[403].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_403] = [__v_8, __v_9, __v_10];
-                if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[403].weight(); } record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -36332,6 +36736,7 @@ fn aiur_fn_404(
   unconstrained: bool,
 ) -> Result<[G; OUT_404], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -36341,7 +36746,7 @@ fn aiur_fn_404(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -36353,13 +36758,13 @@ fn aiur_fn_404(
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_404] = [__v_14, __v_18];
-        if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
         let __v_14: G = __loaded[0];
         let __v_15: G = __loaded[1];
         let __v_16: G = __loaded[2];
@@ -36371,9 +36776,9 @@ fn aiur_fn_404(
             let __v_20: G = G::from_u64(0);
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
-            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_404] = [__v_19, __v_23];
-            if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
@@ -36382,7 +36787,7 @@ fn aiur_fn_404(
                 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_405] = { let __args: [G; IN_405] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0, __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 { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
                 let __v_23: G = __r_arr[1];
                 match __v_22.as_canonical_u64() {
@@ -36391,15 +36796,15 @@ fn aiur_fn_404(
                     let __v_25: G = G::from_u64(0);
                     let __v_26: G = G::from_u64(0);
                     let __v_27: G = G::from_u64(0);
-                    let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_404] = [__v_24, __v_28];
-                    if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_23]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                     let __v_26: G = __loaded[1];
                     let __v_27: G = __loaded[2];
@@ -36420,7 +36825,7 @@ fn aiur_fn_404(
                           0u64 => {
                             match __v_29.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_23]; 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 { let __r = record.function_queries[407].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
                                 match __v_39.as_canonical_u64() {
                                   1u64 => {
@@ -36428,19 +36833,19 @@ fn aiur_fn_404(
                                     let __v_41: G = G::from_u64(0);
                                     let __v_42: G = G::from_u64(0);
                                     let __v_43: G = G::from_u64(0);
-                                    let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_404] = [__v_40, __v_44];
-                                    if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_21]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_40: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_8]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_41: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_40]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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];
                                     match __v_43.as_canonical_u64() {
                                       1u64 => {
@@ -36448,15 +36853,15 @@ fn aiur_fn_404(
                                         let __v_45: G = G::from_u64(0);
                                         let __v_46: G = G::from_u64(0);
                                         let __v_47: G = G::from_u64(0);
-                                        let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_404] = [__v_44, __v_48];
-                                        if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_40, __v_8]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_44, __v_8]; 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 { let __r = record.function_queries[466].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                                         match __v_45.as_canonical_u64() {
                                           1u64 => {
@@ -36464,32 +36869,32 @@ fn aiur_fn_404(
                                             let __v_47: G = G::from_u64(0);
                                             let __v_48: G = G::from_u64(0);
                                             let __v_49: G = G::from_u64(0);
-                                            let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_404] = [__v_46, __v_50];
-                                            if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_12, __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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_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_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_48]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_49: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_46, __v_49]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
                                             let __v_51: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_50, __v_23, __v_40, __v_11, __v_51]; 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 { let __r = record.function_queries[406].replay_at(__i); record.virt += __r; } 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_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_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_54]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_55: G = __r_arr[0];
                                             let __v_56: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_52, __v_55]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
                                             let __ret: [G; OUT_404] = [__v_56, __v_57];
-                                            if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -36503,9 +36908,9 @@ fn aiur_fn_404(
                                 let __v_40: G = G::from_u64(0);
                                 let __v_41: G = G::from_u64(0);
                                 let __v_42: G = G::from_u64(0);
-                                let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_404] = [__v_39, __v_43];
-                                if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -36515,9 +36920,9 @@ fn aiur_fn_404(
                             let __v_40: G = G::from_u64(0);
                             let __v_41: G = G::from_u64(0);
                             let __v_42: G = G::from_u64(0);
-                            let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_404] = [__v_39, __v_43];
-                            if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -36527,9 +36932,9 @@ fn aiur_fn_404(
                         let __v_38: G = G::from_u64(0);
                         let __v_39: G = G::from_u64(0);
                         let __v_40: G = G::from_u64(0);
-                        let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_404] = [__v_37, __v_41];
-                        if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[404].weight(); } record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -36560,21 +36965,22 @@ fn aiur_fn_405(
   unconstrained: bool,
 ) -> Result<[G; OUT_405], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
         let __v_5: G = __loaded[3];
         match __v_2.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -36583,7 +36989,7 @@ fn aiur_fn_405(
               2u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __ret: [G; OUT_405] = [__v_12, __v_9];
-                if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -36620,9 +37026,9 @@ fn aiur_fn_405(
                 let __v_42: G = G::from_u64(0);
                 let __v_43: G = G::from_u64(0);
                 let __v_44: G = G::from_u64(0);
-                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_405] = [__v_12, __v_45];
-                if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -36661,15 +37067,15 @@ fn aiur_fn_405(
             let __v_36: G = G::from_u64(0);
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(0);
-            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_405] = [__v_6, __v_39];
-            if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -36678,11 +37084,11 @@ fn aiur_fn_405(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_4, __v_7]; 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 { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __ret: [G; OUT_405] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -36719,9 +37125,9 @@ fn aiur_fn_405(
             let __v_36: G = G::from_u64(0);
             let __v_37: G = G::from_u64(0);
             let __v_38: G = G::from_u64(0);
-            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_405] = [__v_6, __v_39];
-            if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[405].weight(); } record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -36740,6 +37146,7 @@ fn aiur_fn_406(
   unconstrained: bool,
 ) -> Result<[G; OUT_406], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -36749,21 +37156,21 @@ fn aiur_fn_406(
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_406] = [__v_0];
-        if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[406].weight(); } record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(8);
-        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_4 + __v_11);
-        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_10, __v_1, __v_2, __v_3, __v_12]; 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 { let __r = record.function_queries[406].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __ret: [G; OUT_406] = [__v_13];
-        if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[406].weight(); } record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -36780,10 +37187,11 @@ fn aiur_fn_407(
   unconstrained: bool,
 ) -> Result<[G; OUT_407], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -36798,19 +37206,19 @@ fn aiur_fn_407(
     let __v_13: G = __loaded[11];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_9]; 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 { let __r = record.function_queries[408].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; 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 { let __r = record.function_queries[409].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
         let __ret: [G; OUT_407] = [__v_16];
-        if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[407].weight(); } record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(1);
         let __ret: [G; OUT_407] = [__v_14];
-        if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[407].weight(); } record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -36827,9 +37235,10 @@ fn aiur_fn_408(
   unconstrained: bool,
 ) -> Result<[G; OUT_408], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_1]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -36882,20 +37291,20 @@ fn aiur_fn_408(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_408] = [__v_50];
-            if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[408].weight(); } record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_50: G = G::from_u64(0);
             let __v_51: G = G::from_u64(1);
             let __v_52: G = G::from_u64(1);
-            let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_408] = [__v_54];
-            if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[408].weight(); } record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -36914,6 +37323,7 @@ fn aiur_fn_409(
   unconstrained: bool,
 ) -> Result<[G; OUT_409], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -36925,13 +37335,13 @@ fn aiur_fn_409(
       0u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_409] = [__v_7];
-        if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -36946,24 +37356,24 @@ fn aiur_fn_409(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_3]; 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 { let __r = record.function_queries[410].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_20, __v_4]; 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 { let __r = record.function_queries[411].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
             match __v_21.as_canonical_u64() {
               1u64 => {
                 let __v_22: G = G::from_u64(1);
                 let __ret: [G; OUT_409] = [__v_22];
-                if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_22: G = G::from_u64(1);
                 let __v_23: G = (__v_5 + __v_22);
-                let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; 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 { let __r = record.function_queries[409].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
                 let __ret: [G; OUT_409] = [__v_24];
-                if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -36971,7 +37381,7 @@ fn aiur_fn_409(
           _ => {
             let __v_20: G = G::from_u64(1);
             let __ret: [G; OUT_409] = [__v_20];
-            if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[409].weight(); } record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -36990,16 +37400,17 @@ fn aiur_fn_410(
   unconstrained: bool,
 ) -> Result<[G; OUT_410], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_410] = [__v_0];
-        if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -37008,15 +37419,15 @@ fn aiur_fn_410(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_7]; 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 { let __r = record.function_queries[410].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_410] = [__v_8];
-            if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_410] = [__v_0];
-            if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[410].weight(); } record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -37035,29 +37446,30 @@ fn aiur_fn_411(
   unconstrained: bool,
 ) -> Result<[G; OUT_411], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_411] = [__v_7];
-            if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __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 { let __r = record.function_queries[411].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_411] = [__v_7];
-            if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -37065,7 +37477,7 @@ fn aiur_fn_411(
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_411] = [__v_6];
-        if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[411].weight(); } record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37082,103 +37494,104 @@ fn aiur_fn_412(
   unconstrained: bool,
 ) -> Result<[G; OUT_412], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_3, __v_1]; 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 { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_412] = [__v_6];
-        if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_3, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_412] = [__v_7];
-            if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_4, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_412] = [__v_8];
-                if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 let __ret: [G; OUT_412] = [__v_8];
-                if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -37186,16 +37599,16 @@ fn aiur_fn_412(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_5, __v_1]; 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 { let __r = record.function_queries[412].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_412] = [__v_6];
-        if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_412] = [__v_6];
-        if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[412].weight(); } record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37212,9 +37625,10 @@ fn aiur_fn_413(
   unconstrained: bool,
 ) -> Result<[G; OUT_413], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -37222,24 +37636,24 @@ fn aiur_fn_413(
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_413] = [__v_5];
-        if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
             let __ret: [G; OUT_413] = [__v_6];
-            if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_4]; 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 { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __ret: [G; OUT_413] = [__v_6];
-            if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[413].weight(); } record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -37261,9 +37675,10 @@ fn aiur_fn_414(
   unconstrained: bool,
 ) -> Result<[G; OUT_414], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -37271,41 +37686,41 @@ fn aiur_fn_414(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_414] = [__v_0];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_414] = [__v_0];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __ret: [G; OUT_414] = [__v_0];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_414] = [__v_0];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __ret: [G; OUT_414] = [__v_0];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; 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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_10, __v_7]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __ret: [G; OUT_414] = [__v_11];
-        if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[414].weight(); } record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37322,15 +37737,16 @@ fn aiur_fn_415(
   unconstrained: bool,
 ) -> Result<[G; OUT_415], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_4, __v_1]; 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 { let __r = record.function_queries[374].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __ret: [G; OUT_415] = [__v_5];
-    if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[415].weight(); } record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -37345,9 +37761,10 @@ fn aiur_fn_416(
   unconstrained: bool,
 ) -> Result<[G; OUT_416], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -37355,41 +37772,41 @@ fn aiur_fn_416(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_416] = [__v_0];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_416] = [__v_0];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __ret: [G; OUT_416] = [__v_0];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_416] = [__v_0];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __ret: [G; OUT_416] = [__v_0];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8, __v_10]; 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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __ret: [G; OUT_416] = [__v_11];
-        if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[416].weight(); } record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37406,99 +37823,100 @@ fn aiur_fn_417(
   unconstrained: bool,
 ) -> Result<[G; OUT_417], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_9, __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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __ret: [G; OUT_417] = [__v_10];
-        if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_1, __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 { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } 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 = __r_arr[1];
         let __v_12: G = __r_arr[2];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __ret: [G; OUT_417] = [__v_14];
-            if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_11, __v_14]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_10, __v_15, __v_16]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_17, __v_12, __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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __ret: [G; OUT_417] = [__v_18];
-            if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_11, __v_14]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_15, __v_12, __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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_417] = [__v_16];
-            if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __ret: [G; OUT_417] = [__v_9];
-        if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; 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 { let __r = record.function_queries[418].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_417] = [__v_7];
-        if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_5, __v_0, __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 { let __r = record.function_queries[419].replay_at(__i); record.virt += __r; } 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_417] = [__v_7];
-        if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_417] = [__v_7];
-        if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[417].weight(); } record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37515,27 +37933,28 @@ fn aiur_fn_418(
   unconstrained: bool,
 ) -> Result<[G; OUT_418], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_416] = { let __args: [G; IN_416] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_2, __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 { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; 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 { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_15: G = __loaded[1];
         let __v_16: G = __loaded[2];
@@ -37551,28 +37970,28 @@ fn aiur_fn_418(
         match __v_14.as_canonical_u64() {
           6u64 => {
             let __v_26: G = (__v_20 + __v_1);
-            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_26]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_3, __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 { let __r = record.function_queries[417].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
             let __ret: [G; OUT_418] = [__v_28];
-            if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __ret: [G; OUT_418] = [__v_26];
-            if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __ret: [G; OUT_418] = [__v_13];
-        if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[418].weight(); } record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37589,14 +38008,15 @@ fn aiur_fn_419(
   unconstrained: bool,
 ) -> Result<[G; OUT_419], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -37611,33 +38031,33 @@ fn aiur_fn_419(
     let __v_17: G = __loaded[11];
     match __v_6.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_8, __v_9, __v_11, __v_12, __v_10]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__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[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         match __v_19.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_20, __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 { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
             let __ret: [G; OUT_419] = [__v_21];
-            if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_419] = [__v_21];
-            if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __ret: [G; OUT_419] = [__v_18];
-        if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[419].weight(); } record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37654,9 +38074,10 @@ fn aiur_fn_420(
   unconstrained: bool,
 ) -> Result<[G; OUT_420], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -37664,41 +38085,41 @@ fn aiur_fn_420(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_420] = [__v_0];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_420] = [__v_0];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __ret: [G; OUT_420] = [__v_0];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_420] = [__v_0];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __ret: [G; OUT_420] = [__v_0];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_6]; 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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_10, __v_7]; 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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_420] = [__v_11];
-        if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[420].weight(); } record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37715,15 +38136,16 @@ fn aiur_fn_421(
   unconstrained: bool,
 ) -> Result<[G; OUT_421], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_421] = [__v_5];
-    if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[421].weight(); } record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -37738,63 +38160,64 @@ fn aiur_fn_422(
   unconstrained: bool,
 ) -> Result<[G; OUT_422], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_1]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_9, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_422] = [__v_10];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_0, __v_2]; 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 { let __r = record.function_queries[423].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
         let __ret: [G; OUT_422] = [__v_7];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_4, __v_5, __v_0, __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 { let __r = record.function_queries[425].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_422] = [__v_7];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_5, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_422] = [__v_9];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_4, __v_5, __v_6, __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 { let __r = record.function_queries[424].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_422] = [__v_7];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_422] = [__v_7];
-        if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[422].weight(); } record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37811,47 +38234,48 @@ fn aiur_fn_423(
   unconstrained: bool,
 ) -> Result<[G; OUT_423], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_0, __v_5]; 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 { let __r = record.function_queries[372].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_7]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_0]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_423] = [__v_10];
-        if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_7, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_11, __v_12]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_423] = [__v_14];
-        if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_7, __v_10]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_11, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __ret: [G; OUT_423] = [__v_12];
-        if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[423].weight(); } record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -37868,40 +38292,41 @@ fn aiur_fn_424(
   unconstrained: bool,
 ) -> Result<[G; OUT_424], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_1, __v_7, __v_8]; 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 { let __r = record.function_queries[382].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[1];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_10, __v_3, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_424] = [__v_11];
-        if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7]; 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 { let __r = record.function_queries[383].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_17: G = __loaded[1];
             let __v_18: G = __loaded[2];
@@ -37917,32 +38342,32 @@ fn aiur_fn_424(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_8, __v_28]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_3, __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 { let __r = record.function_queries[422].replay_at(__i); record.virt += __r; } 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_424] = [__v_30];
-                if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_29, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
                 let __ret: [G; OUT_424] = [__v_30];
-                if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_15: G = G::from_u64(8);
-            let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_16, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_424] = [__v_17];
-            if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[424].weight(); } record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -37961,22 +38386,23 @@ fn aiur_fn_425(
   unconstrained: bool,
 ) -> Result<[G; OUT_425], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_387] = { let __args: [G; IN_387] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0]; 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 { let __r = record.function_queries[387].replay_at(__i); record.virt += __r; } 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_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_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_6]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         break '__mc_0 [__v_8, __v_9];
@@ -37986,13 +38412,13 @@ fn aiur_fn_425(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         break '__mc_0 [__v_8, __v_12];
       },
     }
   },
   _ => {
-    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_3, __v_4]; 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 { let __r = record.function_queries[388].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     break '__mc_0 [__v_6, __v_7];
@@ -38003,21 +38429,21 @@ fn aiur_fn_425(
     let __v_7: G = __mc_out___mc_0[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_425] = [__v_8];
-        if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __ret: [G; OUT_425] = [__v_7];
-        if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -38032,43 +38458,43 @@ fn aiur_fn_425(
         let __v_20: G = __loaded[11];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_12, __v_3]; 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 { let __r = record.function_queries[394].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_425] = [__v_23];
-                if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_425] = [__v_23];
-                if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_3, __v_4]; 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 { let __r = record.function_queries[389].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_22, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_425] = [__v_23];
-                if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_425] = [__v_23];
-                if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -38079,10 +38505,10 @@ fn aiur_fn_425(
             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_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_11, __v_23]; 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 { let __r = record.function_queries[405].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
-    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__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[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[397].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
     break '__mc_1 [__v_26, __v_27];
@@ -38098,45 +38524,45 @@ fn aiur_fn_425(
             match __v_24.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_425] = [__v_25];
-                if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_14, __v_15, __v_13]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_26: G = __r_arr[0];
-                let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__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[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[401].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
                 let __v_28: G = __r_arr[1];
                 match __v_27.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_28, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
                     let __ret: [G; OUT_425] = [__v_29];
-                    if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   2u64 => {
                     match __v_17.as_canonical_u64() {
                       1u64 => {
                         let __ret: [G; OUT_425] = [__v_28];
-                        if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__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[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[404].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
                         let __v_30: G = __r_arr[1];
                         match __v_29.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_30, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
                             let __ret: [G; OUT_425] = [__v_31];
-                            if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __ret: [G; OUT_425] = [__v_28];
-                            if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -38144,10 +38570,10 @@ fn aiur_fn_425(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
                     let __ret: [G; OUT_425] = [__v_29];
-                    if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -38155,10 +38581,10 @@ fn aiur_fn_425(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_425] = [__v_21];
-            if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[425].weight(); } record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -38177,17 +38603,18 @@ fn aiur_fn_426(
   unconstrained: bool,
 ) -> Result<[G; OUT_426], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_426] = [__v_6];
-    if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[426].weight(); } record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -38202,6 +38629,7 @@ fn aiur_fn_427(
   unconstrained: bool,
 ) -> Result<[G; OUT_427], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -38217,42 +38645,42 @@ fn aiur_fn_427(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_427] = [__v_1];
-        if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[427].weight(); } record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -38272,6 +38700,7 @@ fn aiur_fn_428(
   unconstrained: bool,
 ) -> Result<[G; OUT_428], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -38287,42 +38716,42 @@ fn aiur_fn_428(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_428] = [__v_2];
-        if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[428].weight(); } record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -38342,47 +38771,48 @@ fn aiur_fn_429(
   unconstrained: bool,
 ) -> Result<[G; OUT_429], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_5]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_8, __v_10, __v_11]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __ret: [G; OUT_429] = [__v_12];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_11]; 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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_429] = [__v_14];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -38395,25 +38825,25 @@ fn aiur_fn_429(
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
         let __v_20: G = __loaded[11];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__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[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
         if (__v_23 != __v_21) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_22, __v_6]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
         let __ret: [G; OUT_429] = [__v_24];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -38421,16 +38851,16 @@ fn aiur_fn_429(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_6, __v_13]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __ret: [G; OUT_429] = [__v_14];
-            if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_15: G = __loaded[1];
             let __v_16: G = __loaded[2];
@@ -38438,10 +38868,10 @@ fn aiur_fn_429(
             match __v_14.as_canonical_u64() {
               5u64 => {
                 let __v_18: G = G::from_u64(0);
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_16, __v_6, __v_18]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
                 let __ret: [G; OUT_429] = [__v_19];
-                if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -38453,68 +38883,68 @@ fn aiur_fn_429(
       },
       4u64 => {
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_6, __v_9]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(5);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_429] = [__v_13];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_5, __v_3]; 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 { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __v_10: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10]; 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 { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_8, __v_11]; 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 { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } 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 __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_429] = [__v_15];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_6, __v_8]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_9, __v_3]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
         let __ret: [G; OUT_429] = [__v_10];
-        if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; 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 { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(1);
             let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_429] = [__v_14];
-            if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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 __v_10: G = G::from_u64(1);
             let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_429] = [__v_14];
-            if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -38523,23 +38953,23 @@ fn aiur_fn_429(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
         let __v_15: G = __loaded[3];
         match __v_12.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_18: G = __loaded[1];
             let __v_19: G = __loaded[2];
@@ -38558,9 +38988,9 @@ fn aiur_fn_429(
             match __v_17.as_canonical_u64() {
               5u64 => {
                 let __v_29: G = G::from_u64(0);
-                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_24, __v_25, __v_29]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_31: G = __loaded[0];
                 let __v_32: G = __loaded[1];
                 let __v_33: G = __loaded[2];
@@ -38579,15 +39009,15 @@ fn aiur_fn_429(
                 }
                 match __v_31.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_33, __v_14]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
-                    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_44, __v_11, __v_20]; 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 { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                     let __v_46: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_45, __v_6, __v_46, __v_5, __v_7]; 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 { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
                     let __ret: [G; OUT_429] = [__v_47];
-                    if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[429].weight(); } record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -38622,43 +39052,44 @@ fn aiur_fn_430(
   unconstrained: bool,
 ) -> Result<[G; OUT_430], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __ret: [G; OUT_430] = [__v_10];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; 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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_430] = [__v_12];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38671,25 +39102,25 @@ fn aiur_fn_430(
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
         let __v_18: G = __loaded[11];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__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[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
         if (__v_21 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_20, __v_4]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
         let __ret: [G; OUT_430] = [__v_22];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -38697,16 +39128,16 @@ fn aiur_fn_430(
         match __v_7.as_canonical_u64() {
           5u64 => {
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_4, __v_11]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __ret: [G; OUT_430] = [__v_12];
-            if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_13: G = __loaded[1];
             let __v_14: G = __loaded[2];
@@ -38714,10 +39145,10 @@ fn aiur_fn_430(
             match __v_12.as_canonical_u64() {
               5u64 => {
                 let __v_16: G = G::from_u64(0);
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_4, __v_16]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                 let __ret: [G; OUT_430] = [__v_17];
-                if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -38729,68 +39160,68 @@ fn aiur_fn_430(
       },
       4u64 => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_7]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(5);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_430] = [__v_11];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_3, __v_1]; 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 { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_8]; 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 { let __r = record.function_queries[431].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; 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 { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_430] = [__v_13];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_6]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __ret: [G; OUT_430] = [__v_8];
-        if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(2);
-            let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; 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 { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_430] = [__v_12];
-            if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = G::from_u64(2);
-            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_430] = [__v_12];
-            if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -38799,23 +39230,23 @@ fn aiur_fn_430(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_11]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
@@ -38834,9 +39265,9 @@ fn aiur_fn_430(
             match __v_15.as_canonical_u64() {
               5u64 => {
                 let __v_27: G = G::from_u64(0);
-                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_22, __v_23, __v_27]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_29: G = __loaded[0];
                 let __v_30: G = __loaded[1];
                 let __v_31: G = __loaded[2];
@@ -38855,15 +39286,15 @@ fn aiur_fn_430(
                 }
                 match __v_29.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_31, __v_12]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_42, __v_9, __v_18]; 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 { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
                     let __v_44: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_43, __v_4, __v_44, __v_3, __v_5]; 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 { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                     let __ret: [G; OUT_430] = [__v_45];
-                    if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[430].weight(); } record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -38898,11 +39329,12 @@ fn aiur_fn_431(
   unconstrained: bool,
 ) -> Result<[G; OUT_431], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -38910,13 +39342,13 @@ fn aiur_fn_431(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_431] = [__v_4];
-        if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[431].weight(); } record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -38924,7 +39356,7 @@ fn aiur_fn_431(
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_431] = [__v_9];
-            if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[431].weight(); } record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -38946,38 +39378,39 @@ fn aiur_fn_432(
   unconstrained: bool,
 ) -> Result<[G; OUT_432], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_432] = [__v_0];
-        if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[432].weight(); } record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         let __v_6: G = __loaded[3];
         match __v_3.as_canonical_u64() {
           5u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_8, __v_10]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_11, __v_9, __v_13]; 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 { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __ret: [G; OUT_432] = [__v_14];
-                if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[432].weight(); } record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -39004,12 +39437,13 @@ fn aiur_fn_433(
   unconstrained: bool,
 ) -> Result<[G; OUT_433], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -39020,21 +39454,21 @@ fn aiur_fn_433(
         match __v_9.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_433] = [__v_6];
-            if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[433].weight(); } record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_7, __v_11, __v_12]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13, __v_1, __v_15, __v_3, __v_4]; 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 { let __r = record.function_queries[433].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
             let __ret: [G; OUT_433] = [__v_16];
-            if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[433].weight(); } record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -39056,15 +39490,16 @@ fn aiur_fn_434(
   unconstrained: bool,
 ) -> Result<[G; OUT_434], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -39072,19 +39507,19 @@ fn aiur_fn_434(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_434] = [__v_8];
-            if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_434] = [__v_8];
-            if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -39092,24 +39527,24 @@ fn aiur_fn_434(
           1u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_434] = [__v_8];
-            if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
                 let __ret: [G; OUT_434] = [__v_9];
-                if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_7]; 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 { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 let __ret: [G; OUT_434] = [__v_9];
-                if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[434].weight(); } record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39136,6 +39571,7 @@ fn aiur_fn_435(
   unconstrained: bool,
 ) -> Result<[G; OUT_435], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -39144,32 +39580,32 @@ fn aiur_fn_435(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_435] = [__v_4];
-        if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_337] = { let __args: [G; IN_337] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_339] = { let __args: [G; IN_339] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5]; 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 { let __r = record.function_queries[340].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = G::from_u64(1);
-            let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __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 { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } 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_435] = [__v_10];
-            if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_1, __v_2, __v_6]; 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 { let __r = record.function_queries[436].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_435] = [__v_7];
-            if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[435].weight(); } record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -39188,48 +39624,49 @@ fn aiur_fn_436(
   unconstrained: bool,
 ) -> Result<[G; OUT_436], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_351] = { let __args: [G; IN_351] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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];
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_5, __v_7]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8, __v_9]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_2, __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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1, __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 { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __ret: [G; OUT_436] = [__v_12];
-        if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[436].weight(); } record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_10, __v_11]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_10, __v_13]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_10]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
         let __v_16: G = (__v_3 - __v_10);
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_15, __v_16]; 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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_12, __v_14, __v_17]; 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 { let __r = record.function_queries[437].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
         let __ret: [G; OUT_436] = [__v_18];
-        if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[436].weight(); } record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39246,23 +39683,24 @@ fn aiur_fn_437(
   unconstrained: bool,
 ) -> Result<[G; OUT_437], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     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_438] = { let __args: [G; IN_438] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __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 { let __r = record.function_queries[438].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __ret: [G; OUT_437] = [__v_4];
-        if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[437].weight(); } record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_0, __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 { let __r = record.function_queries[438].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __ret: [G; OUT_437] = [__v_4];
-        if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[437].weight(); } record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39279,23 +39717,24 @@ fn aiur_fn_438(
   unconstrained: bool,
 ) -> Result<[G; OUT_438], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_438] = [__v_4];
-        if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[438].weight(); } record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[446].replay_at(__i); record.virt += __r; } 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_438] = [__v_4];
-        if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[438].weight(); } record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39312,23 +39751,24 @@ fn aiur_fn_439(
   unconstrained: bool,
 ) -> Result<[G; OUT_439], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       2u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -39338,33 +39778,33 @@ fn aiur_fn_439(
             let __v_15: G = (__v_8 - __v_12);
             match __v_15.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_9, __v_13]; 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 { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
                     let __ret: [G; OUT_439] = [__v_17];
-                    if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; 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 { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                         let __ret: [G; OUT_439] = [__v_20];
-                        if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
                         let __ret: [G; OUT_439] = [__v_20];
-                        if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -39374,7 +39814,7 @@ fn aiur_fn_439(
               _ => {
                 let __v_16: G = G::from_u64(0);
                 let __ret: [G; OUT_439] = [__v_16];
-                if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39382,7 +39822,7 @@ fn aiur_fn_439(
           _ => {
             let __v_15: G = G::from_u64(0);
             let __ret: [G; OUT_439] = [__v_15];
-            if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -39390,7 +39830,7 @@ fn aiur_fn_439(
       _ => {
         let __v_11: G = G::from_u64(0);
         let __ret: [G; OUT_439] = [__v_11];
-        if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[439].weight(); } record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39407,16 +39847,17 @@ fn aiur_fn_440(
   unconstrained: bool,
 ) -> Result<[G; OUT_440], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -39424,19 +39865,19 @@ fn aiur_fn_440(
           1u64 => {
             let __v_9: G = G::from_u64(1);
             let __ret: [G; OUT_440] = [__v_9];
-            if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(0);
             let __ret: [G; OUT_440] = [__v_9];
-            if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -39444,24 +39885,24 @@ fn aiur_fn_440(
           1u64 => {
             let __v_9: G = G::from_u64(0);
             let __ret: [G; OUT_440] = [__v_9];
-            if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_7, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
                 let __ret: [G; OUT_440] = [__v_10];
-                if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_8, __v_2]; 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 { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
                 let __ret: [G; OUT_440] = [__v_10];
-                if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[440].weight(); } record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39488,8 +39929,9 @@ fn aiur_fn_441(
   unconstrained: bool,
 ) -> Result<[G; OUT_441], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -39498,33 +39940,33 @@ fn aiur_fn_441(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             let __ret: [G; OUT_441] = [__v_5];
-            if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
             let __ret: [G; OUT_441] = [__v_5];
-            if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; 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 { let __r = record.function_queries[144].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_441] = [__v_6];
-        if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_441] = [__v_5];
-        if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[441].weight(); } record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39541,8 +39983,9 @@ fn aiur_fn_442(
   unconstrained: bool,
 ) -> Result<[G; OUT_442], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -39554,75 +39997,75 @@ fn aiur_fn_442(
             let __v_5: G = G::from_u64(1);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_442] = [__v_5, __v_9, __v_3];
-            if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8];
-            if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; 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 { let __r = record.function_queries[145].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_442] = { let __args: [G; IN_442] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3]; 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 { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } 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_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_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                 let __ret: [G; OUT_442] = [__v_14, __v_12, __v_15];
-                if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(1);
-                let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_442] = [__v_11, __v_0, __v_14];
-                if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[159].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                     let __v_16: G = __loaded[1];
                     let __v_17: G = __loaded[2];
@@ -39631,23 +40074,23 @@ fn aiur_fn_442(
                       7u64 => {
                         match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__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 { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } 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_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_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_21, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                                 let __ret: [G; OUT_442] = [__v_22, __v_20, __v_23];
-                                if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_22: G = G::from_u64(1);
                                 let __ret: [G; OUT_442] = [__v_22, __v_7, __v_17];
-                                if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -39656,9 +40099,9 @@ fn aiur_fn_442(
                             let __v_19: G = G::from_u64(0);
                             let __v_20: G = G::from_u64(1);
                             let __v_21: G = G::from_u64(1);
-                            let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22];
-                            if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -39667,9 +40110,9 @@ fn aiur_fn_442(
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(1);
                         let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_442] = [__v_19, __v_0, __v_22];
-                        if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -39678,9 +40121,9 @@ fn aiur_fn_442(
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(1);
                     let __v_17: G = G::from_u64(1);
-                    let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_442] = [__v_15, __v_0, __v_18];
-                    if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -39689,9 +40132,9 @@ fn aiur_fn_442(
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_442] = [__v_13, __v_0, __v_16];
-                if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39700,9 +40143,9 @@ fn aiur_fn_442(
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(1);
             let __v_11: G = G::from_u64(1);
-            let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_442] = [__v_9, __v_0, __v_12];
-            if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -39711,9 +40154,9 @@ fn aiur_fn_442(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_442] = [__v_5, __v_0, __v_8];
-        if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[442].weight(); } record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39730,12 +40173,13 @@ fn aiur_fn_443(
   unconstrained: bool,
 ) -> Result<[G; OUT_443], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0]; 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 { let __r = record.function_queries[441].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1]; 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 { let __r = record.function_queries[441].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = (__v_3 * __v_4);
     match __v_5.as_canonical_u64() {
@@ -39743,15 +40187,15 @@ fn aiur_fn_443(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __ret: [G; OUT_443] = [__v_6, __v_7];
-        if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0]; 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 { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = __r_arr[2];
-        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1]; 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 { let __r = record.function_queries[442].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
@@ -39761,26 +40205,26 @@ fn aiur_fn_443(
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
             let __ret: [G; OUT_443] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_8, __v_11]; 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 { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } 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_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_443] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_10, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                 let __ret: [G; OUT_443] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[443].weight(); } record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39801,23 +40245,24 @@ fn aiur_fn_444(
   unconstrained: bool,
 ) -> Result<[G; OUT_444], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_444] = [__v_4];
-        if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[444].weight(); } record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; 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 { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __ret: [G; OUT_444] = [__v_4];
-        if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[444].weight(); } record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39834,10 +40279,11 @@ fn aiur_fn_445(
   unconstrained: bool,
 ) -> Result<[G; OUT_445], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -39846,20 +40292,20 @@ fn aiur_fn_445(
       7u64 => {
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_2]; 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 { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_445] = [__v_9];
-            if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
             let __ret: [G; OUT_445] = [__v_7];
-            if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -39867,7 +40313,7 @@ fn aiur_fn_445(
       _ => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_445] = [__v_7];
-        if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[445].weight(); } record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39884,10 +40330,11 @@ fn aiur_fn_446(
   unconstrained: bool,
 ) -> Result<[G; OUT_446], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
   1u64 => {
@@ -39895,7 +40342,7 @@ fn aiur_fn_446(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_0, __v_2]; 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 { let __r = record.function_queries[445].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     break '__mc_0 [__v_4];
   },
@@ -39906,14 +40353,14 @@ fn aiur_fn_446(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_446] = [__v_5];
-        if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[446].weight(); } record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[447].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __ret: [G; OUT_446] = [__v_5];
-        if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[446].weight(); } record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -39930,46 +40377,47 @@ fn aiur_fn_447(
   unconstrained: bool,
 ) -> Result<[G; OUT_447], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __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 { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[416].replay_at(__i); record.virt += __r; } 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_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_447] = [__v_6];
-        if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_3, __v_4, __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 { let __r = record.function_queries[449].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_447] = [__v_7];
-            if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_4, __v_2]; 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 { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_447] = [__v_8];
-                if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_3, __v_4, __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 { let __r = record.function_queries[448].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 let __ret: [G; OUT_447] = [__v_8];
-                if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[447].weight(); } record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -39990,48 +40438,49 @@ fn aiur_fn_448(
   unconstrained: bool,
 ) -> Result<[G; OUT_448], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __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_448] = [__v_8];
-        if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_6, __v_4]; 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 { let __r = record.function_queries[449].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(1);
             let __ret: [G; OUT_448] = [__v_9];
-            if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_6, __v_4]; 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 { let __r = record.function_queries[439].replay_at(__i); record.virt += __r; } 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];
             match __v_9.as_canonical_u64() {
               1u64 => {
                 let __v_10: G = G::from_u64(1);
                 let __ret: [G; OUT_448] = [__v_10];
-                if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_5, __v_6, __v_4]; 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 { let __r = record.function_queries[450].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
                 let __ret: [G; OUT_448] = [__v_10];
-                if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[448].weight(); } record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -40052,61 +40501,62 @@ fn aiur_fn_449(
   unconstrained: bool,
 ) -> Result<[G; OUT_449], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_449] = [__v_11];
-            if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_449] = [__v_11];
-            if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __ret: [G; OUT_449] = [__v_14];
-                if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_449] = [__v_12];
-                if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -40114,35 +40564,35 @@ fn aiur_fn_449(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_449] = [__v_11];
-            if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __ret: [G; OUT_449] = [__v_14];
-                if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_449] = [__v_12];
-                if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -40150,7 +40600,7 @@ fn aiur_fn_449(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_449] = [__v_11];
-            if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40158,7 +40608,7 @@ fn aiur_fn_449(
       _ => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_449] = [__v_7];
-        if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[449].weight(); } record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -40175,6 +40625,7 @@ fn aiur_fn_450(
   unconstrained: bool,
 ) -> Result<[G; OUT_450], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -40185,62 +40636,62 @@ fn aiur_fn_450(
       0u64 => {
         let __v_6: G = G::from_u64(1);
         let __ret: [G; OUT_450] = [__v_6];
-        if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[464].replay_at(__i); record.virt += __r; } 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_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];
-            if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[462].replay_at(__i); record.virt += __r; } 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];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_450] = [__v_8];
-                if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __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 { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
                     let __ret: [G; OUT_450] = [__v_9];
-                    if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_2, __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 { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                     match __v_9.as_canonical_u64() {
                       1u64 => {
                         let __v_10: G = G::from_u64(1);
                         let __ret: [G; OUT_450] = [__v_10];
-                        if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_2, __v_3, __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 { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } 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];
                         let __v_11: G = __r_arr[1];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
                             let __ret: [G; OUT_450] = [__v_11];
-                            if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_12: G = G::from_u64(16);
-                            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_2, __v_3, __v_12, __v_4]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                             let __v_14: G = __r_arr[1];
                             let __v_15: G = __r_arr[2];
@@ -40248,14 +40699,14 @@ fn aiur_fn_450(
                               1u64 => {
                                 let __v_16: G = G::from_u64(1);
                                 let __ret: [G; OUT_450] = [__v_16];
-                                if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_14, __v_15, __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 { let __r = record.function_queries[451].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
                                 let __ret: [G; OUT_450] = [__v_16];
-                                if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[450].weight(); } record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -40284,37 +40735,38 @@ fn aiur_fn_451(
   unconstrained: bool,
 ) -> Result<[G; OUT_451], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(8);
-    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_3, __v_5, __v_4]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_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_451] = [__v_8];
-        if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_3, __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 { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } 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_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];
-            if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __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 { let __r = record.function_queries[457].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_451] = [__v_9];
-            if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[451].weight(); } record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40333,47 +40785,48 @@ fn aiur_fn_452(
   unconstrained: bool,
 ) -> Result<[G; OUT_452], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_452] = [__v_8];
-        if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_6]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
         let __v_10: G = (__v_8 - __v_9);
         match __v_10.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
             let __v_14: G = __loaded[3];
             match __v_11.as_canonical_u64() {
               8u64 => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_16: G = __loaded[1];
                 let __v_17: G = __loaded[2];
                 let __v_18: G = __loaded[3];
                 match __v_15.as_canonical_u64() {
                   8u64 => {
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
                     let __v_20: G = (__v_13 - __v_17);
                     let __v_21: G = G::from_bool((__v_20 == G::ZERO));
@@ -40383,16 +40836,16 @@ fn aiur_fn_452(
                     let __v_25: G = (__v_19 * __v_24);
                     match __v_25.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_6, __v_2]; 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 { let __r = record.function_queries[440].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
                         let __ret: [G; OUT_452] = [__v_26];
-                        if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_26: G = G::from_u64(0);
                         let __ret: [G; OUT_452] = [__v_26];
-                        if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -40400,7 +40853,7 @@ fn aiur_fn_452(
                   _ => {
                     let __v_19: G = G::from_u64(0);
                     let __ret: [G; OUT_452] = [__v_19];
-                    if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -40408,7 +40861,7 @@ fn aiur_fn_452(
               _ => {
                 let __v_15: G = G::from_u64(0);
                 let __ret: [G; OUT_452] = [__v_15];
-                if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -40416,7 +40869,7 @@ fn aiur_fn_452(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_452] = [__v_11];
-            if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[452].weight(); } record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40435,35 +40888,36 @@ fn aiur_fn_453(
   unconstrained: bool,
 ) -> Result<[G; OUT_453], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_3, __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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_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_453] = [__v_6];
-        if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __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 { let __r = record.function_queries[452].replay_at(__i); record.virt += __r; } 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 __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];
-            if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[454].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_453] = [__v_7];
-            if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[453].weight(); } record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40482,37 +40936,38 @@ fn aiur_fn_454(
   unconstrained: bool,
 ) -> Result<[G; OUT_454], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_4, __v_8, __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 { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_9, __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 { let __r = record.function_queries[453].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __ret: [G; OUT_454] = [__v_12];
-                if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_454] = [__v_12];
-                if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -40520,7 +40975,7 @@ fn aiur_fn_454(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_454] = [__v_11];
-            if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40528,7 +40983,7 @@ fn aiur_fn_454(
       _ => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_454] = [__v_7];
-        if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[454].weight(); } record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -40545,6 +41000,7 @@ fn aiur_fn_455(
   unconstrained: bool,
 ) -> Result<[G; OUT_455], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -40554,18 +41010,18 @@ fn aiur_fn_455(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_455] = [__v_5, __v_2];
-        if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -40577,287 +41033,287 @@ fn aiur_fn_455(
                   0u64 => {
                     let __v_14: G = G::from_u64(1);
                     let __ret: [G; OUT_455] = [__v_14, __v_2];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_14: G = G::from_u64(0);
                     let __ret: [G; OUT_455] = [__v_14, __v_2];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           1u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_6, __v_10]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __ret: [G; OUT_455] = [__v_13, __v_2];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_7, __v_11]; 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 { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                     let __ret: [G; OUT_455] = [__v_14, __v_2];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
                     let __ret: [G; OUT_455] = [__v_14, __v_15];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                     let __v_16: G = __r_arr[1];
                     let __ret: [G; OUT_455] = [__v_15, __v_16];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __ret: [G; OUT_455] = [__v_15, __v_14];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               4u64 => {
-                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                     let __v_18: G = __r_arr[1];
                     let __ret: [G; OUT_455] = [__v_17, __v_18];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __ret: [G; OUT_455] = [__v_15, __v_14];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           5u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_6, __v_10, __v_2, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_7, __v_11, __v_14, __v_16]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                     let __v_18: G = __r_arr[1];
                     let __ret: [G; OUT_455] = [__v_17, __v_18];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __ret: [G; OUT_455] = [__v_15, __v_14];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           7u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_7, __v_10, __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 { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_455] = [__v_13, __v_2];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           8u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 = (__v_7 - __v_11);
                     match __v_14.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_8, __v_12, __v_2, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                         let __v_16: G = __r_arr[1];
                         let __ret: [G; OUT_455] = [__v_15, __v_16];
-                        if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
                         let __ret: [G; OUT_455] = [__v_15, __v_2];
-                        if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
                     let __ret: [G; OUT_455] = [__v_14, __v_15];
-                    if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 let __ret: [G; OUT_455] = [__v_13, __v_14];
-                if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[456].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_455] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[455].weight(); } record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -40876,6 +41332,7 @@ fn aiur_fn_456(
   unconstrained: bool,
 ) -> Result<[G; OUT_456], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -40885,37 +41342,37 @@ fn aiur_fn_456(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_456] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_2 - __v_4);
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __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_456] = [__v_9, __v_5];
-            if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __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 { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_456] = [__v_10, __v_5];
-                if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(8);
-                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_11, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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];
                 let __v_13: G = __r_arr[1];
                 let __v_14: G = __r_arr[2];
@@ -40923,15 +41380,15 @@ fn aiur_fn_456(
                   1u64 => {
                     let __v_15: G = G::from_u64(1);
                     let __ret: [G; OUT_456] = [__v_15, __v_5];
-                    if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_13, __v_14, __v_5, __v_3]; 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 { let __r = record.function_queries[455].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
                     let __v_16: G = __r_arr[1];
                     let __ret: [G; OUT_456] = [__v_15, __v_16];
-                    if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[456].weight(); } record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -40954,86 +41411,87 @@ fn aiur_fn_457(
   unconstrained: bool,
 ) -> Result<[G; OUT_457], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_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_457] = [__v_6];
-        if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[464].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_457] = [__v_7];
-            if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __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 { let __r = record.function_queries[462].replay_at(__i); record.virt += __r; } 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];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_457] = [__v_8];
-                if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __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 { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
                     let __ret: [G; OUT_457] = [__v_9];
-                    if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_4, __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 { let __r = record.function_queries[458].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                     match __v_9.as_canonical_u64() {
                       1u64 => {
                         let __v_10: G = G::from_u64(1);
                         let __ret: [G; OUT_457] = [__v_10];
-                        if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __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 { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } 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];
                         let __v_11: G = __r_arr[1];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
                             let __ret: [G; OUT_457] = [__v_11];
-                            if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_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 { let __r = record.function_queries[461].replay_at(__i); record.virt += __r; } 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];
                             match __v_12.as_canonical_u64() {
                               1u64 => {
                                 let __v_13: G = G::from_u64(1);
                                 let __ret: [G; OUT_457] = [__v_13];
-                                if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_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 { let __r = record.function_queries[467].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                                 let __ret: [G; OUT_457] = [__v_13];
-                                if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[457].weight(); } record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -41062,22 +41520,23 @@ fn aiur_fn_458(
   unconstrained: bool,
 ) -> Result<[G; OUT_458], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_6]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -41092,15 +41551,15 @@ fn aiur_fn_458(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_285] = { let __args: [G; IN_285] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_13, __v_14]; 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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_27: G = __loaded[1];
                 let __v_28: G = __loaded[2];
@@ -41124,41 +41583,41 @@ fn aiur_fn_458(
                       0u64 => {
                         let __v_43: G = G::from_u64(0);
                         let __ret: [G; OUT_458] = [__v_43];
-                        if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_13, __v_14]; 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 { let __r = record.function_queries[460].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
-                        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_43]; 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 { let __r = record.function_queries[407].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
                         match __v_44.as_canonical_u64() {
                           1u64 => {
                             let __v_45: G = G::from_u64(0);
                             let __ret: [G; OUT_458] = [__v_45];
-                            if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_45: G = __r_arr[0];
-                            let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_46: G = __r_arr[0];
-                            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_45, __v_46, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
                             match __v_47.as_canonical_u64() {
                               0u64 => {
                                 let __v_48: G = G::from_u64(0);
                                 let __ret: [G; OUT_458] = [__v_48];
-                                if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_48: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; 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 { let __r = record.function_queries[459].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
                                 let __ret: [G; OUT_458] = [__v_49];
-                                if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -41170,7 +41629,7 @@ fn aiur_fn_458(
                   _ => {
                     let __v_38: G = G::from_u64(0);
                     let __ret: [G; OUT_458] = [__v_38];
-                    if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -41178,7 +41637,7 @@ fn aiur_fn_458(
               _ => {
                 let __v_25: G = G::from_u64(0);
                 let __ret: [G; OUT_458] = [__v_25];
-                if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -41186,7 +41645,7 @@ fn aiur_fn_458(
           _ => {
             let __v_22: G = G::from_u64(0);
             let __ret: [G; OUT_458] = [__v_22];
-            if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41194,7 +41653,7 @@ fn aiur_fn_458(
       _ => {
         let __v_9: G = G::from_u64(0);
         let __ret: [G; OUT_458] = [__v_9];
-        if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[458].weight(); } record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41211,6 +41670,7 @@ fn aiur_fn_459(
   unconstrained: bool,
 ) -> Result<[G; OUT_459], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -41223,31 +41683,31 @@ fn aiur_fn_459(
       0u64 => {
         let __v_8: G = G::from_u64(1);
         let __ret: [G; OUT_459] = [__v_8];
-        if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_10: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_10]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_9, __v_11, __v_6]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           0u64 => {
             let __v_13: G = G::from_u64(0);
             let __ret: [G; OUT_459] = [__v_13];
-            if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_5 + __v_13);
-            let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; 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 { let __r = record.function_queries[459].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __ret: [G; OUT_459] = [__v_15];
-            if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[459].weight(); } record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41266,9 +41726,10 @@ fn aiur_fn_460(
   unconstrained: bool,
 ) -> Result<[G; OUT_460], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -41281,22 +41742,22 @@ fn aiur_fn_460(
     let __v_11: G = G::from_u64(0);
     let __v_12: G = G::from_u64(1);
     let __v_13: G = G::from_u64(1);
-    let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_15: G = G::from_u64(1);
     let __v_16: G = G::from_u64(1);
-    let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_18: G = G::from_u64(1);
     let __v_19: G = G::from_u64(1);
-    let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_460] = [__v_25];
-    if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[460].weight(); } record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -41311,17 +41772,18 @@ fn aiur_fn_461(
   unconstrained: bool,
 ) -> Result<[G; OUT_461], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -41330,36 +41792,36 @@ fn aiur_fn_461(
           4u64 => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_461] = [__v_11];
-            if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __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 { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_461] = [__v_11];
-            if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_8, __v_9, __v_0, __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 { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_461] = [__v_11];
-            if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_461] = [__v_11];
-            if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[461].weight(); } record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41378,29 +41840,30 @@ fn aiur_fn_462(
   unconstrained: bool,
 ) -> Result<[G; OUT_462], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__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 { let __r = record.function_queries[463].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_462] = [__v_6];
-        if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[462].weight(); } record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_6, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_462] = [__v_7];
-        if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[462].weight(); } record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41417,20 +41880,21 @@ fn aiur_fn_463(
   unconstrained: bool,
 ) -> Result<[G; OUT_463], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -41452,9 +41916,9 @@ fn aiur_fn_463(
                 match __v_21.as_canonical_u64() {
                   0u64 => {
                     let __v_22: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_15, __v_16, __v_22]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                     let __v_25: G = __loaded[1];
                     let __v_26: G = __loaded[2];
@@ -41473,13 +41937,13 @@ fn aiur_fn_463(
                           0u64 => {
                             let __v_36: G = G::from_u64(1);
                             let __ret: [G; OUT_463] = [__v_36];
-                            if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_36: G = G::from_u64(0);
                             let __ret: [G; OUT_463] = [__v_36];
-                            if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -41487,7 +41951,7 @@ fn aiur_fn_463(
                       _ => {
                         let __v_36: G = G::from_u64(0);
                         let __ret: [G; OUT_463] = [__v_36];
-                        if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -41495,7 +41959,7 @@ fn aiur_fn_463(
                   _ => {
                     let __v_22: G = G::from_u64(0);
                     let __ret: [G; OUT_463] = [__v_22];
-                    if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -41503,7 +41967,7 @@ fn aiur_fn_463(
               _ => {
                 let __v_20: G = G::from_u64(0);
                 let __ret: [G; OUT_463] = [__v_20];
-                if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -41511,7 +41975,7 @@ fn aiur_fn_463(
           _ => {
             let __v_20: G = G::from_u64(0);
             let __ret: [G; OUT_463] = [__v_20];
-            if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41519,7 +41983,7 @@ fn aiur_fn_463(
       _ => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_463] = [__v_7];
-        if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[463].weight(); } record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41536,27 +42000,28 @@ fn aiur_fn_464(
   unconstrained: bool,
 ) -> Result<[G; OUT_464], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__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 { let __r = record.function_queries[466].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_464] = [__v_5];
-        if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[464].weight(); } record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_2]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_5, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_464] = [__v_6];
-        if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[464].weight(); } record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41573,48 +42038,49 @@ fn aiur_fn_465(
   unconstrained: bool,
 ) -> Result<[G; OUT_465], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_3]; 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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
     let __v_9: G = __loaded[3];
     match __v_6.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_7, __v_3]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_465] = [__v_11];
-            if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_11, __v_12]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_18: G = G::from_u64(3);
             let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_21: G = G::from_u64(0);
-            let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_1, __v_20, __v_22]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
             let __ret: [G; OUT_465] = [__v_23];
-            if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41622,7 +42088,7 @@ fn aiur_fn_465(
       _ => {
         let __v_10: G = G::from_u64(0);
         let __ret: [G; OUT_465] = [__v_10];
-        if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[465].weight(); } record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41639,13 +42105,14 @@ fn aiur_fn_466(
   unconstrained: bool,
 ) -> Result<[G; OUT_466], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __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 { let __r = record.function_queries[429].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -41654,17 +42121,17 @@ fn aiur_fn_466(
       1u64 => {
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_10]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __ret: [G; OUT_466] = [__v_11];
-        if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[466].weight(); } record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_8: G = G::from_u64(0);
         let __ret: [G; OUT_466] = [__v_8];
-        if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[466].weight(); } record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -41681,13 +42148,14 @@ fn aiur_fn_467(
   unconstrained: bool,
 ) -> Result<[G; OUT_467], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __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 { let __r = record.function_queries[468].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __ret: [G; OUT_467] = [__v_3];
-    if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[467].weight(); } record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -41702,17 +42170,18 @@ fn aiur_fn_468(
   unconstrained: bool,
 ) -> Result<[G; OUT_468], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -41724,13 +42193,13 @@ fn aiur_fn_468(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -41738,102 +42207,102 @@ fn aiur_fn_468(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       1u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_8]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_9]; 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 { let __r = record.function_queries[434].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 match __v_12.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                     let __ret: [G; OUT_468] = [__v_13];
-                    if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_13: G = G::from_u64(1);
                     let __ret: [G; OUT_468] = [__v_13];
-                    if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -41841,75 +42310,75 @@ fn aiur_fn_468(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[481].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_14];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_4, __v_5, __v_1, __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 { let __r = record.function_queries[465].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_14];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -41917,7 +42386,7 @@ fn aiur_fn_468(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -41925,39 +42394,39 @@ fn aiur_fn_468(
       6u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_468] = [__v_7];
-        if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __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 { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; 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 { let __r = record.function_queries[396].replay_at(__i); record.virt += __r; } 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_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_468] = [__v_13];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __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 { let __r = record.function_queries[468].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                 let __ret: [G; OUT_468] = [__v_13];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -41965,30 +42434,30 @@ fn aiur_fn_468(
         }
       },
       8u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_12: G = (__v_5 - __v_9);
                 match __v_12.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
                     let __ret: [G; OUT_468] = [__v_13];
-                    if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_13: G = G::from_u64(0);
                     let __ret: [G; OUT_468] = [__v_13];
-                    if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -41996,7 +42465,7 @@ fn aiur_fn_468(
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_468] = [__v_12];
-                if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -42004,7 +42473,7 @@ fn aiur_fn_468(
           _ => {
             let __v_11: G = G::from_u64(0);
             let __ret: [G; OUT_468] = [__v_11];
-            if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[468].weight(); } record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42026,6 +42495,7 @@ fn aiur_fn_469(
   unconstrained: bool,
 ) -> Result<[G; OUT_469], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -42034,7 +42504,7 @@ fn aiur_fn_469(
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_469] = [__v_4, __v_0, __v_1];
-        if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -42043,45 +42513,45 @@ fn aiur_fn_469(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __ret: [G; OUT_469] = [__v_5, __v_0, __v_1];
-            if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __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 { let __r = record.function_queries[443].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             let __v_6: G = __r_arr[1];
             match __v_5.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_469] = [__v_6, __v_0, __v_1];
-                if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; 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 { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; 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 { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } 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_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_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[471].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                         let __v_12: G = __r_arr[1];
                         let __v_13: G = __r_arr[2];
                         let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13];
-                        if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[475].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                         let __v_12: G = __r_arr[1];
                         let __v_13: G = __r_arr[2];
                         let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13];
-                        if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -42089,21 +42559,21 @@ fn aiur_fn_469(
                   _ => {
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_9, __v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[476].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                         let __v_12: G = __r_arr[1];
                         let __v_13: G = __r_arr[2];
                         let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13];
-                        if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[477].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
                         let __v_12: G = __r_arr[1];
                         let __v_13: G = __r_arr[2];
                         let __ret: [G; OUT_469] = [__v_11, __v_12, __v_13];
-                        if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[469].weight(); } record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -42128,6 +42598,7 @@ fn aiur_fn_470(
   unconstrained: bool,
 ) -> Result<[G; OUT_470], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -42143,13 +42614,13 @@ fn aiur_fn_470(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_470] = [__v_5];
-        if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[470].weight(); } record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_470] = [__v_12];
-        if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[470].weight(); } record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42166,15 +42637,16 @@ fn aiur_fn_471(
   unconstrained: bool,
 ) -> Result<[G; OUT_471], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -42187,9 +42659,9 @@ fn aiur_fn_471(
     let __v_16: G = __loaded[9];
     let __v_17: G = __loaded[10];
     let __v_18: G = __loaded[11];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_1]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_21: G = __loaded[1];
     let __v_22: G = __loaded[2];
@@ -42202,9 +42674,9 @@ fn aiur_fn_471(
     let __v_29: G = __loaded[9];
     let __v_30: G = __loaded[10];
     let __v_31: G = __loaded[11];
-    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; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
-    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; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
     match __v_32.as_canonical_u64() {
       0u64 => {
@@ -42212,16 +42684,16 @@ fn aiur_fn_471(
           0u64 => {
             let __v_34: G = G::from_u64(0);
             let __ret: [G; OUT_471] = [__v_34, __v_2, __v_3];
-            if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[473].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
             let __v_36: G = __r_arr[2];
             let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36];
-            if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42229,49 +42701,49 @@ fn aiur_fn_471(
       _ => {
         match __v_33.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[472].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
             let __v_36: G = __r_arr[2];
             let __ret: [G; OUT_471] = [__v_34, __v_35, __v_36];
-            if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__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[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[470].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_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[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[470].replay_at(__i); record.virt += __r; } 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_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_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[472].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
                 let __v_38: G = __r_arr[1];
                 let __v_39: G = __r_arr[2];
                 let __ret: [G; OUT_471] = [__v_37, __v_38, __v_39];
-                if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 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_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[473].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
                     let __v_39: G = __r_arr[1];
                     let __v_40: G = __r_arr[2];
                     let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40];
-                    if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[474].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
                     let __v_39: G = __r_arr[1];
                     let __v_40: G = __r_arr[2];
                     let __ret: [G; OUT_471] = [__v_38, __v_39, __v_40];
-                    if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[471].weight(); } record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -42294,31 +42766,32 @@ fn aiur_fn_472(
   unconstrained: bool,
 ) -> Result<[G; OUT_472], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 - __v_7);
-        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_1, __v_8, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
         let __ret: [G; OUT_472] = [__v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[472].weight(); } record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1];
-        if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[472].weight(); } record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42335,31 +42808,32 @@ fn aiur_fn_473(
   unconstrained: bool,
 ) -> Result<[G; OUT_473], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 - __v_7);
-        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_6, __v_8, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
         let __ret: [G; OUT_473] = [__v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[473].weight(); } record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1];
-        if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[473].weight(); } record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42376,38 +42850,39 @@ fn aiur_fn_474(
   unconstrained: bool,
 ) -> Result<[G; OUT_474], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_1]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_3]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_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_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_11, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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];
             let __v_13: G = __r_arr[1];
             let __v_14: G = __r_arr[2];
             let __ret: [G; OUT_474] = [__v_12, __v_13, __v_14];
-            if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_474] = [__v_8, __v_0, __v_1];
-            if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42415,7 +42890,7 @@ fn aiur_fn_474(
       _ => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_474] = [__v_6, __v_0, __v_1];
-        if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[474].weight(); } record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42432,30 +42907,31 @@ fn aiur_fn_475(
   unconstrained: bool,
 ) -> Result<[G; OUT_475], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_2, __v_4]; 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 { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } 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_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_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_6, __v_8, __v_4]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_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];
-        if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -42468,35 +42944,35 @@ fn aiur_fn_475(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__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[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         match __v_20.as_canonical_u64() {
           0u64 => {
             let __v_21: G = G::from_u64(0);
             let __ret: [G; OUT_475] = [__v_21, __v_1, __v_2];
-            if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } 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_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_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_22, __v_2, __v_24, __v_4]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 let __v_27: G = __r_arr[2];
                 let __ret: [G; OUT_475] = [__v_25, __v_26, __v_27];
-                if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_23: G = G::from_u64(0);
                 let __ret: [G; OUT_475] = [__v_23, __v_1, __v_2];
-                if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[475].weight(); } record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -42517,30 +42993,31 @@ fn aiur_fn_476(
   unconstrained: bool,
 ) -> Result<[G; OUT_476], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_4]; 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 { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } 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_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_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_2, __v_8, __v_4]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_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];
-        if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -42553,35 +43030,35 @@ fn aiur_fn_476(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__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[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[478].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         match __v_20.as_canonical_u64() {
           0u64 => {
             let __v_21: G = G::from_u64(0);
             let __ret: [G; OUT_476] = [__v_21, __v_1, __v_2];
-            if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } 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_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_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_1, __v_22, __v_24, __v_4]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
                 let __v_26: G = __r_arr[1];
                 let __v_27: G = __r_arr[2];
                 let __ret: [G; OUT_476] = [__v_25, __v_26, __v_27];
-                if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_23: G = G::from_u64(0);
                 let __ret: [G; OUT_476] = [__v_23, __v_1, __v_2];
-                if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[476].weight(); } record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -42602,14 +43079,15 @@ fn aiur_fn_477(
   unconstrained: bool,
 ) -> Result<[G; OUT_477], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_479] = { let __args: [G; IN_479] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_0, __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 { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_1, __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 { let __r = record.function_queries[479].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -42618,23 +43096,23 @@ fn aiur_fn_477(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_7, __v_9, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __v_12: G = __r_arr[2];
             let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12];
-            if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_5, __v_1, __v_9, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __v_12: G = __r_arr[2];
             let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12];
-            if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42644,18 +43122,18 @@ fn aiur_fn_477(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_0, __v_7, __v_9, __v_3]; 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 { let __r = record.function_queries[469].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __v_12: G = __r_arr[2];
             let __ret: [G; OUT_477] = [__v_10, __v_11, __v_12];
-            if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1];
-            if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[477].weight(); } record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42674,6 +43152,7 @@ fn aiur_fn_478(
   unconstrained: bool,
 ) -> Result<[G; OUT_478], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -42690,19 +43169,19 @@ fn aiur_fn_478(
       1u64 => {
         let __v_12: G = G::from_u64(1);
         let __ret: [G; OUT_478] = [__v_12];
-        if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_12: G = G::from_u64(1);
         let __ret: [G; OUT_478] = [__v_12];
-        if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_478] = [__v_12];
-        if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[478].weight(); } record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42719,48 +43198,49 @@ fn aiur_fn_479(
   unconstrained: bool,
 ) -> Result<[G; OUT_479], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       8u64 => {
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_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(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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_18: G = { let __values: [G; 4] = [__v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_19: G = G::from_u64(1);
-                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_18, __v_3]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
                 let __ret: [G; OUT_479] = [__v_19, __v_20];
-                if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_17: G = G::from_u64(0);
                 let __ret: [G; OUT_479] = [__v_17, __v_0];
-                if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -42768,7 +43248,7 @@ fn aiur_fn_479(
           _ => {
             let __v_15: G = G::from_u64(1);
             let __ret: [G; OUT_479] = [__v_15, __v_8];
-            if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42776,7 +43256,7 @@ fn aiur_fn_479(
       _ => {
         let __v_8: G = G::from_u64(0);
         let __ret: [G; OUT_479] = [__v_8, __v_0];
-        if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[479].weight(); } record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42793,20 +43273,21 @@ fn aiur_fn_480(
   unconstrained: bool,
 ) -> Result<[G; OUT_480], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -42821,29 +43302,29 @@ fn aiur_fn_480(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             let __ret: [G; OUT_480] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_5]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_2]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             let __ret: [G; OUT_480] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(0);
             let __ret: [G; OUT_480] = [__v_20, __v_0];
-            if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -42851,7 +43332,7 @@ fn aiur_fn_480(
       _ => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_480] = [__v_7, __v_0];
-        if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[480].weight(); } record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -42868,20 +43349,21 @@ fn aiur_fn_481(
   unconstrained: bool,
 ) -> Result<[G; OUT_481], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0]; 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 { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1]; 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 { let __r = record.function_queries[482].replay_at(__i); record.virt += __r; } 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_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_481] = [__v_7];
-        if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -42889,13 +43371,13 @@ fn aiur_fn_481(
           0u64 => {
             let __v_7: G = G::from_u64(0);
             let __ret: [G; OUT_481] = [__v_7];
-            if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -42908,9 +43390,9 @@ fn aiur_fn_481(
             let __v_17: G = __loaded[9];
             let __v_18: G = __loaded[10];
             let __v_19: G = __loaded[11];
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_22: G = __loaded[1];
             let __v_23: G = __loaded[2];
@@ -42923,27 +43405,27 @@ fn aiur_fn_481(
             let __v_30: G = __loaded[9];
             let __v_31: G = __loaded[10];
             let __v_32: G = __loaded[11];
-            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__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[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[483].replay_at(__i); record.virt += __r; } 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_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_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_36, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
                     let __ret: [G; OUT_481] = [__v_37];
-                    if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_34, __v_1, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
                     let __ret: [G; OUT_481] = [__v_37];
-                    if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -42951,16 +43433,16 @@ fn aiur_fn_481(
               0u64 => {
                 match __v_35.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_36, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
                     let __ret: [G; OUT_481] = [__v_37];
-                    if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_37: G = G::from_u64(0);
                     let __ret: [G; OUT_481] = [__v_37];
-                    if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[481].weight(); } record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -42986,11 +43468,12 @@ fn aiur_fn_482(
   unconstrained: bool,
 ) -> Result<[G; OUT_482], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -42999,7 +43482,7 @@ fn aiur_fn_482(
       2u64 => {
         let __v_7: G = G::from_u64(1);
         let __ret: [G; OUT_482] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[482].weight(); } record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43035,10 +43518,10 @@ fn aiur_fn_482(
         let __v_36: G = G::from_u64(0);
         let __v_37: G = G::from_u64(0);
         let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_40: G = G::from_u64(0);
         let __ret: [G; OUT_482] = [__v_39, __v_40];
-        if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[482].weight(); } record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -43055,6 +43538,7 @@ fn aiur_fn_483(
   unconstrained: bool,
 ) -> Result<[G; OUT_483], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -43071,43 +43555,43 @@ fn aiur_fn_483(
     let __v_13: G = inp[13];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_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_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_483] = [__v_16, __v_17];
-            if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_16: G = G::from_u64(0);
             let __ret: [G; OUT_483] = [__v_16, __v_0];
-            if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0]; 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 { let __r = record.function_queries[480].replay_at(__i); record.virt += __r; } 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_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_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_13]; 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 { let __r = record.function_queries[420].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_483] = [__v_16, __v_17];
-            if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_16: G = G::from_u64(0);
             let __ret: [G; OUT_483] = [__v_16, __v_0];
-            if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -43115,7 +43599,7 @@ fn aiur_fn_483(
       _ => {
         let __v_14: G = G::from_u64(0);
         let __ret: [G; OUT_483] = [__v_14, __v_0];
-        if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[483].weight(); } record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -43132,26 +43616,27 @@ fn aiur_fn_484(
   unconstrained: bool,
 ) -> Result<[G; OUT_484], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0]; 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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_5]; 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 { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_484] = [__v_6];
-        if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[484].weight(); } record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[485].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __ret: [G; OUT_484] = [__v_3];
-        if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[484].weight(); } record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -43168,42 +43653,43 @@ fn aiur_fn_485(
   unconstrained: bool,
 ) -> Result<[G; OUT_485], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __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 { let __r = record.function_queries[351].replay_at(__i); record.virt += __r; } 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];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5]; 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 { let __r = record.function_queries[342].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_7]; 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 { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __ret: [G; OUT_485] = [__v_8];
-        if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[485].weight(); } record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_6, __v_7]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_6]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
         let __v_10: G = (__v_2 - __v_6);
-        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_9, __v_10]; 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 { let __r = record.function_queries[350].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_8, __v_11]; 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 { let __r = record.function_queries[486].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_12, __v_6, __v_13]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __ret: [G; OUT_485] = [__v_14];
-        if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[485].weight(); } record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -43220,43 +43706,44 @@ fn aiur_fn_486(
   unconstrained: bool,
 ) -> Result<[G; OUT_486], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_6, __v_8, __v_9]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __ret: [G; OUT_486] = [__v_10];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_9]; 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 { let __r = record.function_queries[330].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_486] = [__v_12];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_3]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
@@ -43269,91 +43756,91 @@ fn aiur_fn_486(
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
         let __v_18: G = __loaded[11];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__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[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[428].replay_at(__i); record.virt += __r; } 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_21: 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_332] = { let __args: [G; IN_332] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_21, __v_4]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
         let __ret: [G; OUT_486] = [__v_22];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_6, __v_1]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_7, __v_11, __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 { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __ret: [G; OUT_486] = [__v_12];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_4, __v_8]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(5);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_486] = [__v_12];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_9]; 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 { let __r = record.function_queries[329].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_486] = [__v_13];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_4, __v_3, __v_1]; 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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_4, __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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_8, __v_1]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __ret: [G; OUT_486] = [__v_9];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_3, __v_4]; 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 { let __r = record.function_queries[488].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_486] = [__v_6];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_3, __v_4, __v_5, __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 { let __r = record.function_queries[494].replay_at(__i); record.virt += __r; } 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_486] = [__v_6];
-        if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[486].weight(); } record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43373,43 +43860,44 @@ fn aiur_fn_487(
   unconstrained: bool,
 ) -> Result<[G; OUT_487], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_487] = [__v_0];
-            if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_8]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_487] = [__v_9];
-            if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
   0u64 => {
@@ -43417,24 +43905,24 @@ fn aiur_fn_487(
   },
   _ => {
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_2, __v_12]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     break '__mc_0 [__v_13];
   },
 }
  };
             let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_12, __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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+            let __v_14: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_6, __v_14, __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 { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __ret: [G; OUT_487] = [__v_15];
-            if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() {
   0u64 => {
@@ -43442,32 +43930,32 @@ fn aiur_fn_487(
   },
   _ => {
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_2, __v_12]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     break '__mc_1 [__v_13];
   },
 }
  };
             let __v_12: G = __mc_out___mc_1[0];
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_15: G = __loaded[1];
             let __v_16: G = __loaded[2];
             let __v_17: G = __loaded[3];
             match __v_14.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_15, __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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(1);
                 let __v_20: G = G::from_u64(1);
-                let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_16, __v_6, __v_22, __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 { let __r = record.function_queries[487].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
                 let __ret: [G; OUT_487] = [__v_23];
-                if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[487].weight(); } record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -43494,33 +43982,34 @@ fn aiur_fn_488(
   unconstrained: bool,
 ) -> Result<[G; OUT_488], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_378] = { let __args: [G; IN_378] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = []; 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 { let __r = record.function_queries[378].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_488] = [__v_8];
-        if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[488].weight(); } record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(2);
-        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_488] = [__v_8];
-        if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[488].weight(); } record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43540,15 +44029,16 @@ fn aiur_fn_489(
   unconstrained: bool,
 ) -> Result<[G; OUT_489], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_4, __v_2, __v_3]; 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 { let __r = record.function_queries[490].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -43557,11 +44047,11 @@ fn aiur_fn_489(
       1u64 => {
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_12]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __ret: [G; OUT_489] = [__v_13];
-        if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[489].weight(); } record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43581,21 +44071,22 @@ fn aiur_fn_490(
   unconstrained: bool,
 ) -> Result<[G; OUT_490], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __ret: [G; OUT_490] = [__v_3];
-        if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -43603,18 +44094,18 @@ fn aiur_fn_490(
         match __v_4.as_canonical_u64() {
           5u64 => {
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_6, __v_11, __v_9]; 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 { let __r = record.function_queries[490].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __ret: [G; OUT_490] = [__v_12];
-            if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_490] = [__v_3];
-            if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[490].weight(); } record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -43633,29 +44124,30 @@ fn aiur_fn_491(
   unconstrained: bool,
 ) -> Result<[G; OUT_491], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_491] = [];
-        if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[491].weight(); } record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_2]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_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_491] = [];
-        if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[491].weight(); } record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -43672,6 +44164,7 @@ fn aiur_fn_492(
   unconstrained: bool,
 ) -> Result<[G; OUT_492], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -43679,32 +44172,32 @@ fn aiur_fn_492(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_492] = [];
-        if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_1, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_7]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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];
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_492] = [];
-            if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[338].replay_at(__i); record.virt += __r; } 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_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_492] = [];
-            if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[492].weight(); } record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -43723,6 +44216,7 @@ fn aiur_fn_493(
   unconstrained: bool,
 ) -> Result<[G; OUT_493], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -43730,7 +44224,7 @@ fn aiur_fn_493(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -43740,24 +44234,24 @@ fn aiur_fn_493(
         let __v_11: G = (__v_1 - __v_2);
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_5, __v_8, __v_6]; 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 { let __r = record.function_queries[491].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_493] = [__v_8];
-            if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[493].weight(); } record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8, __v_9, __v_6]; 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 { let __r = record.function_queries[492].replay_at(__i); record.virt += __r; } 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_12: G = G::from_u64(8);
-            let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_13, __v_14]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[493].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __ret: [G; OUT_493] = [__v_18];
-            if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[493].weight(); } record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -43779,27 +44273,28 @@ fn aiur_fn_494(
   unconstrained: bool,
 ) -> Result<[G; OUT_494], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_484] = { let __args: [G; IN_484] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_9: G = __loaded[1];
     let __v_10: G = __loaded[2];
     let __v_11: G = __loaded[3];
     match __v_8.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -43818,9 +44313,9 @@ fn aiur_fn_494(
         match __v_13.as_canonical_u64() {
           5u64 => {
             let __v_25: G = G::from_u64(0);
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_25]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_27: G = __loaded[0];
             let __v_28: G = __loaded[1];
             let __v_29: G = __loaded[2];
@@ -43839,18 +44334,18 @@ fn aiur_fn_494(
             }
             match __v_27.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_29, __v_10]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
-                let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_40, __v_7, __v_16]; 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 { let __r = record.function_queries[432].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
                 let __v_42: G = (__v_16 + __v_17);
-                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_15, __v_10, __v_42, __v_3]; 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 { let __r = record.function_queries[489].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
                 let __v_44: G = G::from_u64(0);
-                let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; 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 { let __r = record.function_queries[493].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                 let __ret: [G; OUT_494] = [__v_45];
-                if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[494].weight(); } record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -43880,13 +44375,14 @@ fn aiur_fn_495(
   unconstrained: bool,
 ) -> Result<[G; OUT_495], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_2, __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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -43894,7 +44390,7 @@ fn aiur_fn_495(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_495] = [__v_5];
-        if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[495].weight(); } record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43914,19 +44410,20 @@ fn aiur_fn_496(
   unconstrained: bool,
 ) -> Result<[G; OUT_496], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1, __v_2]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_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_496] = [];
-    if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[496].weight(); } record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -43941,6 +44438,7 @@ fn aiur_fn_497(
   unconstrained: bool,
 ) -> Result<[G; OUT_497], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(69);
     let __v_1: G = G::from_u64(96);
     let __v_2: G = G::from_u64(197);
@@ -43973,9 +44471,9 @@ fn aiur_fn_497(
     let __v_29: G = G::from_u64(87);
     let __v_30: G = G::from_u64(47);
     let __v_31: G = G::from_u64(219);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_497] = [__v_32];
-    if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[497].weight(); } record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -43990,6 +44488,7 @@ fn aiur_fn_498(
   unconstrained: bool,
 ) -> Result<[G; OUT_498], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(163);
     let __v_1: G = G::from_u64(245);
     let __v_2: G = G::from_u64(168);
@@ -44022,9 +44521,9 @@ fn aiur_fn_498(
     let __v_29: G = G::from_u64(254);
     let __v_30: G = G::from_u64(51);
     let __v_31: G = G::from_u64(118);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_498] = [__v_32];
-    if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[498].weight(); } record.function_queries[498].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44039,6 +44538,7 @@ fn aiur_fn_499(
   unconstrained: bool,
 ) -> Result<[G; OUT_499], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(46);
     let __v_1: G = G::from_u64(163);
     let __v_2: G = G::from_u64(101);
@@ -44071,9 +44571,9 @@ fn aiur_fn_499(
     let __v_29: G = G::from_u64(157);
     let __v_30: G = G::from_u64(126);
     let __v_31: G = G::from_u64(143);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_499] = [__v_32];
-    if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[499].weight(); } record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44088,6 +44588,7 @@ fn aiur_fn_500(
   unconstrained: bool,
 ) -> Result<[G; OUT_500], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(15);
     let __v_1: G = G::from_u64(158);
     let __v_2: G = G::from_u64(232);
@@ -44120,9 +44621,9 @@ fn aiur_fn_500(
     let __v_29: G = G::from_u64(169);
     let __v_30: G = G::from_u64(131);
     let __v_31: G = G::from_u64(129);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_500] = [__v_32];
-    if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[500].weight(); } record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44137,6 +44638,7 @@ fn aiur_fn_501(
   unconstrained: bool,
 ) -> Result<[G; OUT_501], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(4);
     let __v_1: G = G::from_u64(113);
     let __v_2: G = G::from_u64(228);
@@ -44169,9 +44671,9 @@ fn aiur_fn_501(
     let __v_29: G = G::from_u64(188);
     let __v_30: G = G::from_u64(87);
     let __v_31: G = G::from_u64(149);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_501] = [__v_32];
-    if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[501].weight(); } record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44186,6 +44688,7 @@ fn aiur_fn_502(
   unconstrained: bool,
 ) -> Result<[G; OUT_502], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(4);
     let __v_1: G = G::from_u64(42);
     let __v_2: G = G::from_u64(154);
@@ -44218,9 +44721,9 @@ fn aiur_fn_502(
     let __v_29: G = G::from_u64(213);
     let __v_30: G = G::from_u64(142);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_502] = [__v_32];
-    if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[502].weight(); } record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44235,6 +44738,7 @@ fn aiur_fn_503(
   unconstrained: bool,
 ) -> Result<[G; OUT_503], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(125);
     let __v_1: G = G::from_u64(175);
     let __v_2: G = G::from_u64(170);
@@ -44267,9 +44771,9 @@ fn aiur_fn_503(
     let __v_29: G = G::from_u64(166);
     let __v_30: G = G::from_u64(175);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_503] = [__v_32];
-    if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[503].weight(); } record.function_queries[503].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44284,6 +44788,7 @@ fn aiur_fn_504(
   unconstrained: bool,
 ) -> Result<[G; OUT_504], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(248);
     let __v_1: G = G::from_u64(49);
     let __v_2: G = G::from_u64(57);
@@ -44316,9 +44821,9 @@ fn aiur_fn_504(
     let __v_29: G = G::from_u64(178);
     let __v_30: G = G::from_u64(58);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_504] = [__v_32];
-    if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[504].weight(); } record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44333,6 +44838,7 @@ fn aiur_fn_505(
   unconstrained: bool,
 ) -> Result<[G; OUT_505], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(122);
     let __v_1: G = G::from_u64(236);
     let __v_2: G = G::from_u64(194);
@@ -44365,9 +44871,9 @@ fn aiur_fn_505(
     let __v_29: G = G::from_u64(183);
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(194);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_505] = [__v_32];
-    if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[505].weight(); } record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44382,6 +44888,7 @@ fn aiur_fn_506(
   unconstrained: bool,
 ) -> Result<[G; OUT_506], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(230);
     let __v_1: G = G::from_u64(235);
     let __v_2: G = G::from_u64(163);
@@ -44414,9 +44921,9 @@ fn aiur_fn_506(
     let __v_29: G = G::from_u64(201);
     let __v_30: G = G::from_u64(160);
     let __v_31: G = G::from_u64(164);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_506] = [__v_32];
-    if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[506].weight(); } record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44431,6 +44938,7 @@ fn aiur_fn_507(
   unconstrained: bool,
 ) -> Result<[G; OUT_507], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(108);
     let __v_1: G = G::from_u64(155);
     let __v_2: G = G::from_u64(214);
@@ -44463,9 +44971,9 @@ fn aiur_fn_507(
     let __v_29: G = G::from_u64(167);
     let __v_30: G = G::from_u64(173);
     let __v_31: G = G::from_u64(206);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_507] = [__v_32];
-    if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[507].weight(); } record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44480,6 +44988,7 @@ fn aiur_fn_508(
   unconstrained: bool,
 ) -> Result<[G; OUT_508], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(15);
     let __v_1: G = G::from_u64(83);
     let __v_2: G = G::from_u64(188);
@@ -44512,9 +45021,9 @@ fn aiur_fn_508(
     let __v_29: G = G::from_u64(207);
     let __v_30: G = G::from_u64(244);
     let __v_31: G = G::from_u64(248);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_508] = [__v_32];
-    if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[508].weight(); } record.function_queries[508].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44529,6 +45038,7 @@ fn aiur_fn_509(
   unconstrained: bool,
 ) -> Result<[G; OUT_509], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(14);
     let __v_1: G = G::from_u64(95);
     let __v_2: G = G::from_u64(112);
@@ -44561,9 +45071,9 @@ fn aiur_fn_509(
     let __v_29: G = G::from_u64(66);
     let __v_30: G = G::from_u64(63);
     let __v_31: G = G::from_u64(174);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_509] = [__v_32];
-    if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[509].weight(); } record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44578,6 +45088,7 @@ fn aiur_fn_510(
   unconstrained: bool,
 ) -> Result<[G; OUT_510], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(206);
     let __v_1: G = G::from_u64(19);
     let __v_2: G = G::from_u64(124);
@@ -44610,9 +45121,9 @@ fn aiur_fn_510(
     let __v_29: G = G::from_u64(1);
     let __v_30: G = G::from_u64(16);
     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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_510] = [__v_32];
-    if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[510].weight(); } record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44627,82 +45138,83 @@ fn aiur_fn_511(
   unconstrained: bool,
 ) -> Result<[G; OUT_511], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; 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 { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_3];
-        if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; 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 { let __r = record.function_queries[498].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_5];
-            if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; 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 { let __r = record.function_queries[499].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_7];
-                if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; 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 { let __r = record.function_queries[509].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_9];
-                    if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; 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 { let __r = record.function_queries[508].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-                    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_11];
-                        if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; 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 { let __r = record.function_queries[510].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-                        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_511] = [__v_13];
-                            if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_13: G = G::from_u64(0);
                             let __ret: [G; OUT_511] = [__v_13];
-                            if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[511].weight(); } record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -44729,46 +45241,47 @@ fn aiur_fn_512(
   unconstrained: bool,
 ) -> Result<[G; OUT_512], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; 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 { let __r = record.function_queries[509].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_512] = [__v_3];
-        if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; 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 { let __r = record.function_queries[508].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_512] = [__v_5];
-            if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; 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 { let __r = record.function_queries[510].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_512] = [__v_7];
-                if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_7: G = G::from_u64(0);
                 let __ret: [G; OUT_512] = [__v_7];
-                if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[512].weight(); } record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -44789,28 +45302,29 @@ fn aiur_fn_513(
   unconstrained: bool,
 ) -> Result<[G; OUT_513], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_13: G = (__v_10 + __v_12);
             match __v_13.as_canonical_u64() {
@@ -44819,13 +45333,13 @@ fn aiur_fn_513(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(1);
                 let __v_17: G = G::from_u64(1);
-                let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_513] = [__v_14, __v_15, __v_18];
-                if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_15: G = __loaded[1];
                 let __v_16: G = __loaded[2];
@@ -44836,7 +45350,7 @@ fn aiur_fn_513(
                       0u64 => {
                         let __v_18: G = G::from_u64(1);
                         let __ret: [G; OUT_513] = [__v_18, __v_12, __v_16];
-                        if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -44844,9 +45358,9 @@ fn aiur_fn_513(
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(1);
                         let __v_21: G = G::from_u64(1);
-                        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22];
-                        if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -44856,9 +45370,9 @@ fn aiur_fn_513(
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(1);
                     let __v_21: G = G::from_u64(1);
-                    let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_513] = [__v_18, __v_19, __v_22];
-                    if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -44870,9 +45384,9 @@ fn aiur_fn_513(
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_513] = [__v_9, __v_10, __v_13];
-            if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -44882,9 +45396,9 @@ fn aiur_fn_513(
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_513] = [__v_5, __v_6, __v_9];
-        if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[513].weight(); } record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -44901,16 +45415,17 @@ fn aiur_fn_514(
   unconstrained: bool,
 ) -> Result<[G; OUT_514], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
@@ -44920,18 +45435,18 @@ fn aiur_fn_514(
     let __v_3: G = G::from_u64(2);
     let __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_7: G = G::from_u64(0);
-    let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_9: G = G::from_u64(7);
     let __v_10: G = G::from_u64(0);
     let __v_11: G = G::from_u64(0);
-    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_13: G = G::from_u64(3);
     let __v_14: G = G::from_u64(0);
-    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_514] = [__v_15];
-    if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[514].weight(); } record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -44946,11 +45461,12 @@ fn aiur_fn_515(
   unconstrained: bool,
 ) -> Result<[G; OUT_515], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -44960,25 +45476,25 @@ fn aiur_fn_515(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_515] = [__v_7, __v_11];
-        if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_7]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_8]; 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 { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } 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_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_513] = { let __args: [G; IN_513] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_10]; 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 { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -44988,27 +45504,27 @@ fn aiur_fn_515(
                 let __v_18: G = G::from_u64(0);
                 let __v_19: G = G::from_u64(0);
                 let __v_20: G = G::from_u64(0);
-                let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_515] = [__v_17, __v_21];
-                if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; 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 { let __r = record.function_queries[516].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
                 let __v_18: G = __r_arr[1];
                 let __ret: [G; OUT_515] = [__v_17, __v_18];
-                if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; 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 { let __r = record.function_queries[516].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __ret: [G; OUT_515] = [__v_14, __v_15];
-            if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[515].weight(); } record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -45027,49 +45543,50 @@ fn aiur_fn_516(
   unconstrained: bool,
 ) -> Result<[G; OUT_516], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_6]; 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 { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } 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_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_513] = { let __args: [G; IN_513] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_7]; 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 { let __r = record.function_queries[513].replay_at(__i); record.virt += __r; } 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_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_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_10]; 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 { let __r = record.function_queries[514].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_12, __v_13]; 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 { let __r = record.function_queries[514].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(2);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_19: G = G::from_u64(3);
             let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_22: G = G::from_u64(3);
             let __v_23: G = G::from_u64(0);
-            let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_25: G = G::from_u64(2);
-            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_25]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_26: G = __r_arr[0];
             let __v_27: G = G::from_u64(1);
-            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_24, __v_26]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_516] = [__v_27, __v_28];
-            if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -45077,9 +45594,9 @@ fn aiur_fn_516(
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_516] = [__v_14, __v_18];
-            if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -45089,9 +45606,9 @@ fn aiur_fn_516(
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_516] = [__v_11, __v_15];
-        if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[516].weight(); } record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45108,11 +45625,12 @@ fn aiur_fn_517(
   unconstrained: bool,
 ) -> Result<[G; OUT_517], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -45122,51 +45640,51 @@ fn aiur_fn_517(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_517] = [__v_7, __v_11];
-        if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_0]; 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 { let __r = record.function_queries[512].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[515].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __ret: [G; OUT_517] = [__v_8, __v_9];
-            if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; 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 { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_498] = { let __args: [G; IN_498] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = []; 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 { let __r = record.function_queries[498].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_499] = { let __args: [G; IN_499] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = []; 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 { let __r = record.function_queries[499].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[518].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __ret: [G; OUT_517] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[519].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
                 let __ret: [G; OUT_517] = [__v_14, __v_15];
-                if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[517].weight(); } record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -45187,18 +45705,19 @@ fn aiur_fn_518(
   unconstrained: bool,
 ) -> Result<[G; OUT_518], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_3]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(1);
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_5]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_7]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     match __v_8.as_canonical_u64() {
@@ -45207,35 +45726,35 @@ fn aiur_fn_518(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_518] = [__v_10, __v_14];
-        if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[518].weight(); } record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_9]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_241(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } } else { aiur_fn_241(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(2);
-        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = []; 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 { let __r = record.function_queries[497].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_16: G = G::from_u64(3);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_19: G = G::from_u64(3);
         let __v_20: G = G::from_u64(0);
-        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_1, __v_22]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
         let __v_24: G = G::from_u64(1);
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_21, __v_23]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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];
         let __ret: [G; OUT_518] = [__v_24, __v_25];
-        if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[518].weight(); } record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -45255,6 +45774,7 @@ fn aiur_fn_519(
   unconstrained: bool,
 ) -> Result<[G; OUT_519], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -45262,16 +45782,16 @@ fn aiur_fn_519(
     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_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_6]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_8]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_10]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     match __v_12.as_canonical_u64() {
@@ -45280,13 +45800,13 @@ fn aiur_fn_519(
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_519] = [__v_14, __v_18];
-        if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_11]; 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 { let __r = record.function_queries[240].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -45295,31 +45815,31 @@ fn aiur_fn_519(
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
             let __v_19: G = G::from_u64(0);
-            let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_519] = [__v_16, __v_20];
-            if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             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_120] = { let __args: [G; IN_120] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13, __v_15]; 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 { let __r = record.function_queries[121].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
   _ => {
-    let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_13, __v_15]; 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 { let __r = record.function_queries[335].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
 }
  };
             let __v_16: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__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[520].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[520].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
             let __ret: [G; OUT_519] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[519].weight(); } record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -45344,6 +45864,7 @@ fn aiur_fn_520(
   unconstrained: bool,
 ) -> Result<[G; OUT_520], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -45362,44 +45883,44 @@ fn aiur_fn_520(
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_520] = [__v_12, __v_16];
-        if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[520].weight(); } record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(0);
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_16: G = G::from_u64(0);
-        let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_18: G = G::from_u64(0);
         let __v_19: G = G::from_u64(1);
         let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_23: G = G::from_u64(2);
-        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; 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 { let __r = record.function_queries[507].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
         let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_27: G = G::from_u64(2);
-        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; 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 { let __r = record.function_queries[506].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = G::from_u64(1);
         let __v_30: G = G::from_u64(1);
-        let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_32: G = G::from_u64(0);
-        let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
   _ => {
-    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[174].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
@@ -45409,25 +45930,25 @@ fn aiur_fn_520(
         let __v_35: G = G::from_u64(2);
         let __v_36: G = G::from_u64(1);
         let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_41: G = G::from_u64(3);
         let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_44: G = G::from_u64(3);
         let __v_45: G = G::from_u64(0);
-        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() {
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; 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 { let __r = record.function_queries[502].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
       _ => {
-        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; 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 { let __r = record.function_queries[503].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
@@ -45436,12 +45957,12 @@ fn aiur_fn_520(
   _ => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; 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 { let __r = record.function_queries[504].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
       _ => {
-        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; 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 { let __r = record.function_queries[505].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
@@ -45453,23 +45974,23 @@ fn aiur_fn_520(
         let __v_48: G = G::from_u64(2);
         let __v_49: G = G::from_u64(1);
         let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_52: G = G::from_u64(0);
-        let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_54: G = G::from_u64(3);
         let __v_55: G = G::from_u64(0);
-        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_57: G = G::from_u64(3);
         let __v_58: G = G::from_u64(0);
-        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_60: G = G::from_u64(3);
         let __v_61: G = G::from_u64(0);
-        let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[523].replay_at(__i); record.virt += __r; } 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_63: G = __r_arr[0];
         let __v_64: G = __r_arr[1];
         let __ret: [G; OUT_520] = [__v_63, __v_64];
-        if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[520].weight(); } record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45486,10 +46007,11 @@ fn aiur_fn_521(
   unconstrained: bool,
 ) -> Result<[G; OUT_521], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_1]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -45499,19 +46021,19 @@ fn aiur_fn_521(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_521] = [__v_6, __v_10];
-        if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_8]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_11: G = __loaded[1];
         let __v_12: G = __loaded[2];
@@ -45520,7 +46042,7 @@ fn aiur_fn_521(
           7u64 => {
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+                let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_15: G = __loaded[1];
                 let __v_16: G = __loaded[2];
@@ -45529,7 +46051,7 @@ fn aiur_fn_521(
                   7u64 => {
                     match __v_15.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_16]; 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 { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
                         match __v_18.as_canonical_u64() {
                           0u64 => {
@@ -45537,17 +46059,17 @@ fn aiur_fn_521(
                             let __v_20: G = G::from_u64(0);
                             let __v_21: G = G::from_u64(0);
                             let __v_22: G = G::from_u64(0);
-                            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_521] = [__v_19, __v_23];
-                            if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_12, __v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[522].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
                             let __v_20: G = __r_arr[1];
                             let __ret: [G; OUT_521] = [__v_19, __v_20];
-                            if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -45557,9 +46079,9 @@ fn aiur_fn_521(
                         let __v_19: G = G::from_u64(0);
                         let __v_20: G = G::from_u64(0);
                         let __v_21: G = G::from_u64(0);
-                        let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_521] = [__v_18, __v_22];
-                        if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -45569,9 +46091,9 @@ fn aiur_fn_521(
                     let __v_19: G = G::from_u64(0);
                     let __v_20: G = G::from_u64(0);
                     let __v_21: G = G::from_u64(0);
-                    let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_521] = [__v_18, __v_22];
-                    if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -45581,9 +46103,9 @@ fn aiur_fn_521(
                 let __v_15: G = G::from_u64(0);
                 let __v_16: G = G::from_u64(0);
                 let __v_17: G = G::from_u64(0);
-                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_521] = [__v_14, __v_18];
-                if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -45593,9 +46115,9 @@ fn aiur_fn_521(
             let __v_15: G = G::from_u64(0);
             let __v_16: G = G::from_u64(0);
             let __v_17: G = G::from_u64(0);
-            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_521] = [__v_14, __v_18];
-            if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[521].weight(); } record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -45614,6 +46136,7 @@ fn aiur_fn_522(
   unconstrained: bool,
 ) -> Result<[G; OUT_522], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -45621,56 +46144,56 @@ fn aiur_fn_522(
     let __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_10: G = G::from_u64(0);
     let __v_11: G = G::from_u64(1);
     let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_15: G = G::from_u64(2);
-    let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; 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 { let __r = record.function_queries[507].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     let __v_17: G = G::from_u64(0);
-    let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_19: G = G::from_u64(2);
-    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_24: G = G::from_u64(0);
-    let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_26: G = G::from_u64(7);
     let __v_27: G = G::from_u64(1);
     let __v_28: G = G::from_u64(0);
-    let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_30: G = G::from_u64(3);
     let __v_31: G = G::from_u64(0);
-    let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_33: G = G::from_u64(3);
     let __v_34: G = G::from_u64(0);
-    let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(2);
     let __v_37: G = G::from_u64(1);
     let __v_38: G = G::from_u64(1);
-    let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_40: G = G::from_u64(0);
-    let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_42: G = G::from_u64(2);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2, __v_42]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_43]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_44, __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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_3]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_46]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -45680,37 +46203,37 @@ fn aiur_fn_522(
         let __v_53: G = G::from_u64(0);
         let __v_54: G = G::from_u64(0);
         let __v_55: G = G::from_u64(0);
-        let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_522] = [__v_52, __v_56];
-        if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[522].weight(); } record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_52: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_48, __v_52]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_53: G = __r_arr[0];
         let __v_54: G = G::from_u64(2);
-        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; 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 { let __r = record.function_queries[500].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
         let __v_56: G = G::from_u64(1);
         let __v_57: G = G::from_u64(1);
-        let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_59: G = G::from_u64(0);
-        let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_61: G = G::from_u64(3);
         let __v_62: G = G::from_u64(0);
-        let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_64: G = G::from_u64(3);
         let __v_65: G = G::from_u64(0);
-        let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_67: G = G::from_u64(2);
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_67]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_68: G = __r_arr[0];
         let __v_69: G = G::from_u64(1);
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_66, __v_68]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
         let __ret: [G; OUT_522] = [__v_69, __v_70];
-        if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[522].weight(); } record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45727,6 +46250,7 @@ fn aiur_fn_523(
   unconstrained: bool,
 ) -> Result<[G; OUT_523], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -45735,12 +46259,12 @@ fn aiur_fn_523(
     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_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; 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 { let __r = record.function_queries[500].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     break '__mc_0 [__v_6];
   },
   _ => {
-    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; 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 { let __r = record.function_queries[501].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     break '__mc_0 [__v_6];
   },
@@ -45749,20 +46273,20 @@ fn aiur_fn_523(
     let __v_6: G = __mc_out___mc_0[0];
     let __v_7: G = G::from_u64(2);
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_10: G = G::from_u64(2);
-    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __v_10]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_12, __v_5]; 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 { let __r = record.function_queries[484].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_13, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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 };
@@ -45772,35 +46296,35 @@ fn aiur_fn_523(
         let __v_21: G = G::from_u64(0);
         let __v_22: G = G::from_u64(0);
         let __v_23: G = G::from_u64(0);
-        let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_523] = [__v_20, __v_24];
-        if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[523].weight(); } record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_16, __v_20]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
         let __v_22: G = G::from_u64(2);
         let __v_23: G = G::from_u64(1);
         let __v_24: G = G::from_u64(1);
-        let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_28: G = G::from_u64(3);
         let __v_29: G = G::from_u64(0);
-        let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_31: G = G::from_u64(3);
         let __v_32: G = G::from_u64(0);
-        let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_34: G = G::from_u64(2);
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_4, __v_34]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_35: G = __r_arr[0];
         let __v_36: G = G::from_u64(1);
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_33, __v_35]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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];
         let __ret: [G; OUT_523] = [__v_36, __v_37];
-        if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[523].weight(); } record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45817,6 +46341,7 @@ fn aiur_fn_524(
   unconstrained: bool,
 ) -> Result<[G; OUT_524], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = (__v_0 - __v_1);
@@ -45824,7 +46349,7 @@ fn aiur_fn_524(
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_524] = [__v_3];
-        if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -45833,13 +46358,13 @@ fn aiur_fn_524(
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __ret: [G; OUT_524] = [__v_4];
-            if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_4: G = G::from_u64(2);
             let __ret: [G; OUT_524] = [__v_4];
-            if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[524].weight(); } record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -45861,17 +46386,18 @@ fn aiur_fn_525(
   unconstrained: bool,
 ) -> Result<[G; OUT_525], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_525] = [__v_1];
-        if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[525].weight(); } record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_525] = [__v_0];
-        if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[525].weight(); } record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45888,10 +46414,11 @@ fn aiur_fn_526(
   unconstrained: bool,
 ) -> Result<[G; OUT_526], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
     let __ret: [G; OUT_526] = [__v_0, __v_1];
-    if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[526].weight(); } record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -45906,10 +46433,11 @@ fn aiur_fn_527(
   unconstrained: bool,
 ) -> Result<[G; OUT_527], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(1);
     let __v_1: G = G::from_u64(1);
     let __ret: [G; OUT_527] = [__v_0, __v_1];
-    if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[527].weight(); } record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -45924,10 +46452,11 @@ fn aiur_fn_528(
   unconstrained: bool,
 ) -> Result<[G; OUT_528], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(2);
     let __v_1: G = G::from_u64(1);
     let __ret: [G; OUT_528] = [__v_0, __v_1];
-    if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[528].weight(); } record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -45942,6 +46471,7 @@ fn aiur_fn_529(
   unconstrained: bool,
 ) -> Result<[G; OUT_529], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -45950,12 +46480,12 @@ fn aiur_fn_529(
       1u64 => {
         let __v_4: G = (__v_1 * __v_3);
         let __ret: [G; OUT_529] = [__v_2, __v_4];
-        if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[529].weight(); } record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_529] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[529].weight(); } record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -45972,10 +46502,11 @@ fn aiur_fn_530(
   unconstrained: bool,
 ) -> Result<[G; OUT_530], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
     let __ret: [G; OUT_530] = [__v_0, __v_1];
-    if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[530].weight(); } record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -45990,9 +46521,10 @@ fn aiur_fn_531(
   unconstrained: bool,
 ) -> Result<[G; OUT_531], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -46025,7 +46557,7 @@ fn aiur_fn_531(
     let __v_31: G = __loaded[29];
     let __v_32: G = __loaded[30];
     let __v_33: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -46058,38 +46590,38 @@ fn aiur_fn_531(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; 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 { let __r = record.function_queries[532].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_72, __v_73]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_74]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_70, __v_75]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_69, __v_76]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_68, __v_77]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_67, __v_78]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_66, __v_79]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
     let __ret: [G; OUT_531] = [__v_80];
-    if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[531].weight(); } record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -46104,6 +46636,7 @@ fn aiur_fn_532(
   unconstrained: bool,
 ) -> Result<[G; OUT_532], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -46130,10 +46663,10 @@ fn aiur_fn_532(
     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_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_16, __v_25]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
     let __ret: [G; OUT_532] = [__v_26];
-    if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[532].weight(); } record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -46148,9 +46681,10 @@ fn aiur_fn_533(
   unconstrained: bool,
 ) -> Result<[G; OUT_533], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -46159,25 +46693,25 @@ fn aiur_fn_533(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_533] = [__v_6];
-        if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_8: G = (__v_7 + __v_4);
             let __ret: [G; OUT_533] = [__v_8];
-            if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_5]; 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 { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
             let __ret: [G; OUT_533] = [__v_7];
-            if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[533].weight(); } record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -46199,44 +46733,45 @@ fn aiur_fn_534(
   unconstrained: bool,
 ) -> Result<[G; OUT_534], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __ret: [G; OUT_534] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_2]; 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 { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_2]; 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 { let __r = record.function_queries[533].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
             match __v_5.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1]; 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 { let __r = record.function_queries[531].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_6]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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];
                 let __v_8: G = __r_arr[1];
                 let __ret: [G; OUT_534] = [__v_7, __v_8];
-                if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
                 let __v_7: G = __r_arr[1];
                 let __ret: [G; OUT_534] = [__v_6, __v_7];
-                if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -46244,19 +46779,19 @@ fn aiur_fn_534(
           _ => {
             match __v_5.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
                 let __v_7: G = __r_arr[1];
                 let __ret: [G; OUT_534] = [__v_6, __v_7];
-                if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
                 let __v_7: G = G::from_u64(0);
                 let __ret: [G; OUT_534] = [__v_6, __v_7];
-                if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[534].weight(); } record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -46277,15 +46812,16 @@ fn aiur_fn_535(
   unconstrained: bool,
 ) -> Result<[G; OUT_535], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46293,19 +46829,19 @@ fn aiur_fn_535(
           0u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46313,26 +46849,26 @@ fn aiur_fn_535(
           0u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46340,36 +46876,36 @@ fn aiur_fn_535(
           0u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __ret: [G; OUT_535] = [__v_10];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46377,36 +46913,36 @@ fn aiur_fn_535(
           0u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_4, __v_7]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __ret: [G; OUT_535] = [__v_10];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46415,22 +46951,22 @@ fn aiur_fn_535(
         }
       },
       4u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_535] = [__v_8];
-            if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[535].weight(); } record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -46452,15 +46988,16 @@ fn aiur_fn_536(
   unconstrained: bool,
 ) -> Result<[G; OUT_536], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46468,19 +47005,19 @@ fn aiur_fn_536(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_536] = [__v_8];
-            if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_536] = [__v_8];
-            if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46488,18 +47025,18 @@ fn aiur_fn_536(
           1u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_536] = [__v_8];
-            if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_3, __v_6]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_4, __v_7]; 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 { let __r = record.function_queries[536].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __ret: [G; OUT_536] = [__v_10];
-            if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[536].weight(); } record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46524,6 +47061,7 @@ fn aiur_fn_537(
   unconstrained: bool,
 ) -> Result<[G; OUT_537], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -46532,16 +47070,16 @@ fn aiur_fn_537(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __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 { let __r = record.function_queries[538].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
             let __ret: [G; OUT_537] = [__v_4];
-            if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __ret: [G; OUT_537] = [__v_4];
-            if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46554,14 +47092,14 @@ fn aiur_fn_537(
           0u64 => {
             let __v_4: G = G::from_u64(2);
             let __ret: [G; OUT_537] = [__v_4];
-            if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; 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 { let __r = record.function_queries[541].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
             let __ret: [G; OUT_537] = [__v_4];
-            if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[537].weight(); } record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46586,29 +47124,30 @@ fn aiur_fn_538(
   unconstrained: bool,
 ) -> Result<[G; OUT_538], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2]; 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 { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3]; 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 { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_5]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_3]; 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 { let __r = record.function_queries[539].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_538] = [__v_7];
-        if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[538].weight(); } record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_538] = [__v_6];
-        if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[538].weight(); } record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -46625,9 +47164,10 @@ fn aiur_fn_539(
   unconstrained: bool,
 ) -> Result<[G; OUT_539], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -46642,11 +47182,11 @@ fn aiur_fn_539(
       1u64 => {
         let __v_12: G = G::from_u64(1);
         let __ret: [G; OUT_539] = [__v_12];
-        if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[539].weight(); } record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -46659,14 +47199,14 @@ fn aiur_fn_539(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11, __v_21]; 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 { let __r = record.function_queries[539].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__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[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[540].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
             let __ret: [G; OUT_539] = [__v_24];
-            if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[539].weight(); } record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46691,6 +47231,7 @@ fn aiur_fn_540(
   unconstrained: bool,
 ) -> Result<[G; OUT_540], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -46707,38 +47248,38 @@ fn aiur_fn_540(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_15]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_14]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_13]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_12]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_11]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_10]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_9]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_8]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_22, __v_23]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_21, __v_24]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_20, __v_25]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_19, __v_26]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_18, __v_27]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_17, __v_28]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_16, __v_29]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
     let __ret: [G; OUT_540] = [__v_30];
-    if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[540].weight(); } record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -46753,15 +47294,16 @@ fn aiur_fn_541(
   unconstrained: bool,
 ) -> Result<[G; OUT_541], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46769,19 +47311,19 @@ fn aiur_fn_541(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_541] = [__v_8];
-            if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_541] = [__v_8];
-            if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -46789,18 +47331,18 @@ fn aiur_fn_541(
           1u64 => {
             let __v_8: G = G::from_u64(2);
             let __ret: [G; OUT_541] = [__v_8];
-            if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_6]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_7]; 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 { let __r = record.function_queries[541].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9]; 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 { let __r = record.function_queries[525].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __ret: [G; OUT_541] = [__v_10];
-            if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[541].weight(); } record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -46825,35 +47367,36 @@ fn aiur_fn_542(
   unconstrained: bool,
 ) -> Result<[G; OUT_542], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = (__v_0 - __v_1);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __ret: [G; OUT_542] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[542].weight(); } record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
-        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__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[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[543].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __ret: [G; OUT_542] = [__v_12, __v_13];
-        if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[542].weight(); } record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -46870,6 +47413,7 @@ fn aiur_fn_543(
   unconstrained: bool,
 ) -> Result<[G; OUT_543], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -46883,21 +47427,21 @@ fn aiur_fn_543(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_5]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_10, __v_11];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -46905,29 +47449,29 @@ fn aiur_fn_543(
       1u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_1, __v_5]; 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 { let __r = record.function_queries[535].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_10, __v_11];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -46935,43 +47479,43 @@ fn aiur_fn_543(
       2u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_6]; 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 { let __r = record.function_queries[536].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; 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 { let __r = record.function_queries[534].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_10, __v_11, __v_12, __v_13]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_14, __v_15];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -46979,49 +47523,49 @@ fn aiur_fn_543(
       3u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47029,57 +47573,57 @@ fn aiur_fn_543(
       4u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47087,65 +47631,65 @@ fn aiur_fn_543(
       5u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47153,79 +47697,79 @@ fn aiur_fn_543(
       6u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_5, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_6, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_15, __v_16]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47233,29 +47777,29 @@ fn aiur_fn_543(
       7u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_5, __v_6]; 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 { let __r = record.function_queries[537].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_9]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_10, __v_11];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47263,33 +47807,33 @@ fn aiur_fn_543(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_5, __v_8]; 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 { let __r = record.function_queries[534].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_2, __v_6]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_12, __v_13, __v_14, __v_15]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_9, __v_10, __v_16, __v_17]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_18, __v_19];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             let __ret: [G; OUT_543] = [__v_9, __v_10];
-            if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[543].weight(); } record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47311,6 +47855,7 @@ fn aiur_fn_544(
   unconstrained: bool,
 ) -> Result<[G; OUT_544], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47322,19 +47867,19 @@ fn aiur_fn_544(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_4]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_5, __v_6]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9, __v_10, __v_11]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __ret: [G; OUT_544] = [__v_12, __v_13];
-            if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[544].weight(); } record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47353,10 +47898,11 @@ fn aiur_fn_545(
   unconstrained: bool,
 ) -> Result<[G; OUT_545], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -47364,7 +47910,7 @@ fn aiur_fn_545(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -47372,25 +47918,25 @@ fn aiur_fn_545(
         let __v_12: G = __loaded[4];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_545] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[526].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_545] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+        let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -47398,25 +47944,25 @@ fn aiur_fn_545(
         let __v_12: G = __loaded[4];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[528].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             let __ret: [G; OUT_545] = [__v_13, __v_14];
-            if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; 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 { let __r = record.function_queries[544].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_12, __v_2]; 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 { let __r = record.function_queries[545].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
             let __ret: [G; OUT_545] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[545].weight(); } record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -47441,6 +47987,7 @@ fn aiur_fn_546(
   unconstrained: bool,
 ) -> Result<[G; OUT_546], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47457,49 +48004,49 @@ fn aiur_fn_546(
       1u64 => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_12: G = G::from_u64(1);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_12: G = G::from_u64(2);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_12: G = G::from_u64(3);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_12: G = G::from_u64(4);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_12: G = G::from_u64(5);
         let __ret: [G; OUT_546] = [__v_12];
-        if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[546].weight(); } record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -47519,6 +48066,7 @@ fn aiur_fn_547(
   unconstrained: bool,
 ) -> Result<[G; OUT_547], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47544,27 +48092,27 @@ fn aiur_fn_547(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
     match __v_27.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[548].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __ret: [G; OUT_547] = [__v_28, __v_29];
-        if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[547].weight(); } record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __ret: [G; OUT_547] = [__v_28, __v_29];
-        if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[547].weight(); } record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -47581,6 +48129,7 @@ fn aiur_fn_548(
   unconstrained: bool,
 ) -> Result<[G; OUT_548], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47610,33 +48159,33 @@ fn aiur_fn_548(
       1u64 => {
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_3, __v_15, __v_24]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_28, __v_29, __v_30, __v_31]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_32, __v_33]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
             let __ret: [G; OUT_548] = [__v_34, __v_35];
-            if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
             let __ret: [G; OUT_548] = [__v_25, __v_26];
-            if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47644,75 +48193,75 @@ fn aiur_fn_548(
       5u64 => {
         match __v_12.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_35, __v_36]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_37, __v_38]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_39, __v_40]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
             match __v_43.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_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_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; 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 { let __r = record.function_queries[549].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
                 let __v_48: G = __r_arr[1];
-                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_44, __v_45, __v_47, __v_48]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
                 let __v_50: G = __r_arr[1];
-                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_49, __v_50]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
                 let __v_52: G = __r_arr[1];
                 let __ret: [G; OUT_548] = [__v_51, __v_52];
-                if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_43]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
                 let __v_45: G = __r_arr[1];
-                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_44, __v_45]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
                 let __v_47: G = __r_arr[1];
                 let __ret: [G; OUT_548] = [__v_46, __v_47];
-                if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
             let __ret: [G; OUT_548] = [__v_25, __v_26];
-            if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -47720,83 +48269,83 @@ fn aiur_fn_548(
       7u64 => {
         match __v_12.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_3, __v_15]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_4, __v_16]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_37]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_8, __v_20]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_40]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_7, __v_19, __v_24]; 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 { let __r = record.function_queries[545].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_43, __v_44, __v_45, __v_46]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
             let __v_48: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_41, __v_42, __v_47, __v_48]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_38, __v_39, __v_49, __v_50]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_51, __v_52]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_53, __v_54]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_55, __v_56]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_57, __v_58]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
             let __ret: [G; OUT_548] = [__v_59, __v_60];
-            if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
             let __ret: [G; OUT_548] = [__v_25, __v_26];
-            if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
         let __v_26: G = __r_arr[1];
         let __ret: [G; OUT_548] = [__v_25, __v_26];
-        if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[548].weight(); } record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -47813,6 +48362,7 @@ fn aiur_fn_549(
   unconstrained: bool,
 ) -> Result<[G; OUT_549], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47823,17 +48373,17 @@ fn aiur_fn_549(
     let __v_7: G = (__v_4 - __v_6);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[527].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __ret: [G; OUT_549] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[549].weight(); } record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -47846,9 +48396,9 @@ fn aiur_fn_549(
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
         let __v_20: G = __loaded[11];
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_23: G = __loaded[1];
         let __v_24: G = __loaded[2];
@@ -47861,19 +48411,19 @@ fn aiur_fn_549(
         let __v_31: G = __loaded[9];
         let __v_32: G = __loaded[10];
         let __v_33: G = __loaded[11];
-        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_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; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_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[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[550].replay_at(__i); record.virt += __r; } 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_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_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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 { let __r = record.function_queries[549].replay_at(__i); record.virt += __r; } 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_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_34, __v_35, __v_38, __v_39]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
         let __v_41: G = __r_arr[1];
         let __ret: [G; OUT_549] = [__v_40, __v_41];
-        if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[549].weight(); } record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -47890,6 +48440,7 @@ fn aiur_fn_550(
   unconstrained: bool,
 ) -> Result<[G; OUT_550], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -47919,73 +48470,73 @@ fn aiur_fn_550(
       6u64 => {
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_1, __v_13]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_25]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_5, __v_17]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_28]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_6, __v_18]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_31]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_7, __v_19]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_34]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_14, __v_24]; 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 { let __r = record.function_queries[542].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_35, __v_36, __v_37, __v_38]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_32, __v_33, __v_39, __v_40]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_29, __v_30, __v_41, __v_42]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_27, __v_43, __v_44]; 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 { let __r = record.function_queries[529].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
             let __ret: [G; OUT_550] = [__v_45, __v_46];
-            if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
             let __ret: [G; OUT_550] = [__v_28, __v_29];
-            if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__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[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[546].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_25, __v_26]; 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 { let __r = record.function_queries[524].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_27]; 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 { let __r = record.function_queries[530].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __ret: [G; OUT_550] = [__v_28, __v_29];
-        if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[550].weight(); } record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -48002,11 +48553,12 @@ fn aiur_fn_551(
   unconstrained: bool,
 ) -> Result<[G; OUT_551], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -48015,7 +48567,7 @@ fn aiur_fn_551(
     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_289] = { let __args: [G; IN_289] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2]; 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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     let __v_14: G = __r_arr[2];
@@ -48027,22 +48579,22 @@ fn aiur_fn_551(
     let __v_20: G = G::from_u64(0);
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_24: G = G::from_u64(1);
     let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_27: G = G::from_u64(1);
     let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_30: G = G::from_u64(1);
     let __v_31: G = G::from_u64(1);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_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[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_551] = [__v_34];
-    if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[551].weight(); } record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -48057,13 +48609,14 @@ fn aiur_fn_552(
   unconstrained: bool,
 ) -> Result<[G; OUT_552], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_1]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -48077,7 +48630,7 @@ fn aiur_fn_552(
     let __v_14: G = __loaded[10];
     let __v_15: G = __loaded[11];
     let __ret: [G; OUT_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[552].weight(); } record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -48092,9 +48645,10 @@ fn aiur_fn_553(
   unconstrained: bool,
 ) -> Result<[G; OUT_553], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1]; 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 { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -48110,13 +48664,13 @@ fn aiur_fn_553(
     match __v_2.as_canonical_u64() {
       5u64 => {
         let __ret: [G; OUT_553] = [__v_7];
-        if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[553].weight(); } record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
         let __ret: [G; OUT_553] = [__v_14];
-        if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[553].weight(); } record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -48133,16 +48687,17 @@ fn aiur_fn_554(
   unconstrained: bool,
 ) -> Result<[G; OUT_554], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __ret: [G; OUT_554] = [__v_5];
-    if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[554].weight(); } record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -48157,12 +48712,13 @@ fn aiur_fn_555(
   unconstrained: bool,
 ) -> Result<[G; OUT_555], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -48170,24 +48726,24 @@ fn aiur_fn_555(
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_555] = [__v_10];
-        if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[555].weight(); } record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_6, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[556].replay_at(__i); record.virt += __r; } 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_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_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_7, __v_1, __v_2, __v_11, __v_12]; 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 { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_8, __v_13]; 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 { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
         let __ret: [G; OUT_555] = [__v_14];
-        if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[555].weight(); } record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -48207,12 +48763,13 @@ fn aiur_fn_556(
   unconstrained: bool,
 ) -> Result<[G; OUT_556], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -48220,37 +48777,37 @@ fn aiur_fn_556(
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(0);
         let __ret: [G; OUT_556] = [__v_10, __v_11];
-        if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[556].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_6]; 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 { let __r = record.function_queries[553].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_2, __v_6, __v_10, __v_4, __v_11]; 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 { let __r = record.function_queries[557].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_6]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_8]; 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 { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
-        let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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_556] = [__v_16, __v_10];
-            if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_556] = [__v_16, __v_9];
-            if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[556].weight(); } record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -48272,6 +48829,7 @@ fn aiur_fn_557(
   unconstrained: bool,
 ) -> Result<[G; OUT_557], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -48282,23 +48840,23 @@ fn aiur_fn_557(
       0u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_557] = [__v_8];
-        if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[557].weight(); } record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_4]; 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 { let __r = record.function_queries[551].replay_at(__i); record.virt += __r; } 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_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_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_10]; 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 { let __r = record.function_queries[557].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_557] = [__v_12];
-        if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[557].weight(); } record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -48315,22 +48873,23 @@ fn aiur_fn_558(
   unconstrained: bool,
 ) -> Result<[G; OUT_558], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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 __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_8: G = G::from_u64(1);
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
     let __v_10: G = (__v_8 + __v_9);
-    let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; 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 { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __ret: [G; OUT_558] = [__v_11];
-    if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[558].weight(); } record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -48345,6 +48904,7 @@ fn aiur_fn_559(
   unconstrained: bool,
 ) -> Result<[G; OUT_559], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -48352,32 +48912,32 @@ fn aiur_fn_559(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_559] = [__v_0];
-        if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_4, __v_5]; 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 { let __r = record.function_queries[555].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_6, __v_1]; 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 { let __r = record.function_queries[560].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_7]; 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 { let __r = record.function_queries[566].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_559] = [__v_0];
-            if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_3 - __v_9);
-            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_10]; 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 { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __ret: [G; OUT_559] = [__v_11];
-            if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[559].weight(); } record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -48396,10 +48956,11 @@ fn aiur_fn_560(
   unconstrained: bool,
 ) -> Result<[G; OUT_560], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -48407,20 +48968,20 @@ fn aiur_fn_560(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_560] = [__v_8];
-        if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[560].weight(); } record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_4, __v_1, __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 { let __r = record.function_queries[561].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_5, __v_1, __v_2]; 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 { let __r = record.function_queries[560].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_6, __v_7]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __ret: [G; OUT_560] = [__v_8];
-        if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[560].weight(); } record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -48440,37 +49001,38 @@ fn aiur_fn_561(
   unconstrained: bool,
 ) -> Result<[G; OUT_561], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_561] = [__v_6];
-        if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_561] = [__v_8];
-        if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __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 { let __r = record.function_queries[562].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __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 { let __r = record.function_queries[564].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __ret: [G; OUT_561] = [__v_5];
-        if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[561].weight(); } record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -48487,10 +49049,11 @@ fn aiur_fn_562(
   unconstrained: bool,
 ) -> Result<[G; OUT_562], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -48498,18 +49061,18 @@ fn aiur_fn_562(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_562] = [__v_8];
-        if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[562].weight(); } record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_5, __v_1, __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 { let __r = record.function_queries[562].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_6, __v_1, __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 { let __r = record.function_queries[563].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_562] = [__v_7];
-        if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[562].weight(); } record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -48529,11 +49092,12 @@ fn aiur_fn_563(
   unconstrained: bool,
 ) -> Result<[G; OUT_563], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -48542,14 +49106,14 @@ fn aiur_fn_563(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = G::from_u64(1);
-        let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_563] = [__v_11];
-        if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __v_0]; 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 { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[1];
         let __v_9: G = __r_arr[2];
@@ -48562,7 +49126,7 @@ fn aiur_fn_563(
         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_552] = { let __args: [G; IN_552] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_3, __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 { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -48575,24 +49139,24 @@ fn aiur_fn_563(
         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_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[547].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_34: G = { let __values: [G; 3] = [__v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_563] = [__v_34];
-            if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_2, __v_3]; 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 { let __r = record.function_queries[563].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_563] = [__v_35];
-            if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[563].weight(); } record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -48614,10 +49178,11 @@ fn aiur_fn_564(
   unconstrained: bool,
 ) -> Result<[G; OUT_564], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -48625,21 +49190,21 @@ fn aiur_fn_564(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_564] = [__v_8];
-        if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[564].weight(); } record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2, __v_4, __v_10]; 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 { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __ret: [G; OUT_564] = [__v_11];
-        if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[564].weight(); } record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -48659,12 +49224,13 @@ fn aiur_fn_565(
   unconstrained: bool,
 ) -> Result<[G; OUT_565], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -48673,14 +49239,14 @@ fn aiur_fn_565(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_565] = [__v_12];
-        if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __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 { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
@@ -48693,7 +49259,7 @@ fn aiur_fn_565(
         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_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_2, __v_6]; 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 { let __r = record.function_queries[552].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -48706,17 +49272,17 @@ fn aiur_fn_565(
         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_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[547].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
         let __v_33: G = __r_arr[1];
         match __v_32.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_6]; 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 { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_34]; 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 { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
             let __ret: [G; OUT_565] = [__v_35];
-            if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -48724,13 +49290,13 @@ fn aiur_fn_565(
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(1);
             let __v_37: G = G::from_u64(1);
-            let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_6, __v_39]; 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 { let __r = record.function_queries[565].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
-            let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_565] = [__v_41];
-            if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[565].weight(); } record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -48752,15 +49318,16 @@ fn aiur_fn_566(
   unconstrained: bool,
 ) -> Result<[G; OUT_566], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -48768,19 +49335,19 @@ fn aiur_fn_566(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_566] = [__v_8];
-            if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_566] = [__v_8];
-            if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -48788,24 +49355,24 @@ fn aiur_fn_566(
           1u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_566] = [__v_8];
-            if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
                 let __ret: [G; OUT_566] = [__v_9];
-                if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_7]; 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 { let __r = record.function_queries[566].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
                 let __ret: [G; OUT_566] = [__v_9];
-                if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[566].weight(); } record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -48832,8 +49399,9 @@ fn aiur_fn_567(
   unconstrained: bool,
 ) -> Result<[G; OUT_567], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -48841,18 +49409,18 @@ fn aiur_fn_567(
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_567] = [__v_6];
-        if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[567].weight(); } record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_3]; 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 { let __r = record.function_queries[567].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_2, __v_4]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
         let __ret: [G; OUT_567] = [__v_5];
-        if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[567].weight(); } record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -48872,8 +49440,9 @@ fn aiur_fn_568(
   unconstrained: bool,
 ) -> Result<[G; OUT_568], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -48881,24 +49450,24 @@ fn aiur_fn_568(
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_568] = [__v_4];
-        if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_3]; 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 { let __r = record.function_queries[568].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
             let __ret: [G; OUT_568] = [__v_5];
-            if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
             let __ret: [G; OUT_568] = [__v_5];
-            if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[568].weight(); } record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -48920,9 +49489,10 @@ fn aiur_fn_569(
   unconstrained: bool,
 ) -> Result<[G; OUT_569], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -48974,27 +49544,27 @@ fn aiur_fn_569(
       1u64 => {
         let __v_49: G = G::from_u64(1);
         let __v_50: G = G::from_u64(1);
-        let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_569] = [__v_51];
-        if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         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_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_48, __v_50]; 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 { let __r = record.function_queries[569].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_53: G = { let __values: [G; 3] = [__v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_569] = [__v_53];
-            if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_569] = [__v_51];
-            if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[569].weight(); } record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -49016,9 +49586,10 @@ fn aiur_fn_570(
   unconstrained: bool,
 ) -> Result<[G; OUT_570], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -49070,7 +49641,7 @@ fn aiur_fn_570(
       1u64 => {
         let __v_49: G = G::from_u64(0);
         let __ret: [G; OUT_570] = [__v_49];
-        if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -49097,14 +49668,14 @@ fn aiur_fn_570(
           1u64 => {
             let __v_50: G = G::from_u64(1);
             let __ret: [G; OUT_570] = [__v_50];
-            if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_48, __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 { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
             let __ret: [G; OUT_570] = [__v_50];
-            if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[570].weight(); } record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -49126,8 +49697,9 @@ fn aiur_fn_571(
   unconstrained: bool,
 ) -> Result<[G; OUT_571], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -49181,66 +49753,66 @@ fn aiur_fn_571(
         match __v_1.as_canonical_u64() {
           8u64 => {
             let __v_49: G = G::from_u64(0);
-            let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_2, __v_49]; 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 { let __r = record.function_queries[569].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
             let __v_51: G = G::from_u64(1);
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_51]; 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 { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
             let __v_53: G = G::from_u64(0);
-            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_53]; 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 { let __r = record.function_queries[570].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
             let __v_55: G = (__v_52 * __v_54);
             let __v_56: G = G::from_u64(0);
             if (__v_55 != __v_56) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) });
             }
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_571] = [];
-                if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __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 { let __r = record.function_queries[292].replay_at(__i); record.virt += __r; } 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_60: G = __r_arr[0];
                 let __v_61: G = G::from_u64(0);
                 let __v_62: G = G::from_u64(1);
                 let __v_63: G = G::from_u64(1);
-                let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_66: G = G::from_u64(1);
-                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_50]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_67: G = __r_arr[0];
                 let __v_68: G = (__v_66 + __v_67);
-                let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_65, __v_60, __v_0, __v_68]; 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 { let __r = record.function_queries[559].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
-                let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_69]; 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 { let __r = record.function_queries[568].replay_at(__i); record.virt += __r; } 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_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_567] = { let __args: [G; IN_567] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_69]; 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 { let __r = record.function_queries[567].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
-                let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_72, __v_50]; 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 { let __r = record.function_queries[336].replay_at(__i); record.virt += __r; } 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_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_571] = [];
-                if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __ret: [G; OUT_571] = [];
-            if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[571].weight(); } record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -49259,6 +49831,7 @@ fn aiur_fn_572(
   unconstrained: bool,
 ) -> Result<[G; OUT_572], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -49274,7 +49847,7 @@ fn aiur_fn_572(
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_572] = [__v_3];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
@@ -49282,13 +49855,13 @@ fn aiur_fn_572(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __ret: [G; OUT_572] = [__v_12];
-            if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(1);
             let __ret: [G; OUT_572] = [__v_12];
-            if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -49296,33 +49869,33 @@ fn aiur_fn_572(
       2u64 => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_572] = [__v_12];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __ret: [G; OUT_572] = [__v_4];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_572] = [__v_12];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __ret: [G; OUT_572] = [__v_6];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __ret: [G; OUT_572] = [__v_8];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_572] = [__v_9];
-        if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[572].weight(); } record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49342,8 +49915,9 @@ fn aiur_fn_573(
   unconstrained: bool,
 ) -> Result<[G; OUT_573], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -49352,19 +49926,19 @@ fn aiur_fn_573(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_573] = [__v_5];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_573] = [__v_5];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -49378,67 +49952,67 @@ fn aiur_fn_573(
         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_572] = { let __args: [G; IN_572] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__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[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[572].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = (__v_18 - __v_19);
         let __ret: [G; OUT_573] = [__v_20];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
         let __ret: [G; OUT_573] = [__v_7];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
         let __ret: [G; OUT_573] = [__v_7];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
         let __ret: [G; OUT_573] = [__v_7];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __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_573] = [__v_9];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_573] = [__v_5];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __v_5: G = __r_arr[0];
         let __ret: [G; OUT_573] = [__v_5];
-        if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[573].weight(); } record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49458,23 +50032,24 @@ fn aiur_fn_574(
   unconstrained: bool,
 ) -> Result<[G; OUT_574], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_574] = [];
-        if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[574].weight(); } record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_1]; 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 { let __r = record.function_queries[573].replay_at(__i); record.virt += __r; } 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 __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_574] = [];
-        if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[574].weight(); } record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -49491,36 +50066,37 @@ fn aiur_fn_575(
   unconstrained: bool,
 ) -> Result<[G; OUT_575], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_575] = [];
-        if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_575] = [];
-        if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_575] = [];
-        if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_575] = [];
-        if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
@@ -49530,7 +50106,7 @@ fn aiur_fn_575(
           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_575] = [];
-        if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[575].weight(); } record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49550,23 +50126,24 @@ fn aiur_fn_576(
   unconstrained: bool,
 ) -> Result<[G; OUT_576], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_576] = [];
-        if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[576].weight(); } record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_3, __v_1]; 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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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_576] = { let __args: [G; IN_576] = [__v_4, __v_1]; 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 { let __r = record.function_queries[576].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_576] = [];
-        if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[576].weight(); } record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49586,10 +50163,11 @@ fn aiur_fn_577(
   unconstrained: bool,
 ) -> Result<[G; OUT_577], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -49602,19 +50180,19 @@ fn aiur_fn_577(
           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_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __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 { let __r = record.function_queries[575].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -49627,62 +50205,62 @@ fn aiur_fn_577(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__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[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[427].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_5]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_576] = { let __args: [G; IN_576] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __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 { let __r = record.function_queries[576].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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_577] = { let __args: [G; IN_577] = [__v_5, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_8, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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_577] = { let __args: [G; IN_577] = [__v_5, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
         let __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_577] = [];
-        if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[577].weight(); } record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49702,6 +50280,7 @@ fn aiur_fn_578(
   unconstrained: bool,
 ) -> Result<[G; OUT_578], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(171);
     let __v_1: G = G::from_u64(104);
     let __v_2: G = G::from_u64(44);
@@ -49734,9 +50313,9 @@ fn aiur_fn_578(
     let __v_29: G = G::from_u64(99);
     let __v_30: G = G::from_u64(202);
     let __v_31: G = G::from_u64(184);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __ret: [G; OUT_578] = [__v_32];
-    if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[578].weight(); } record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -49751,6 +50330,7 @@ fn aiur_fn_579(
   unconstrained: bool,
 ) -> Result<[G; OUT_579], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -49759,11 +50339,11 @@ fn aiur_fn_579(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_579] = [__v_4];
-        if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -49772,16 +50352,16 @@ fn aiur_fn_579(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_6, __v_1, __v_9]; 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 { let __r = record.function_queries[579].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __ret: [G; OUT_579] = [__v_10];
-            if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_579] = [__v_8];
-            if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[579].weight(); } record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -49800,6 +50380,7 @@ fn aiur_fn_580(
   unconstrained: bool,
 ) -> Result<[G; OUT_580], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = G::from_u64(3);
     let __v_1: G = G::from_u64(107);
     let __v_2: G = G::from_u64(99);
@@ -49832,10 +50413,10 @@ fn aiur_fn_580(
     let __v_29: G = G::from_u64(200);
     let __v_30: G = G::from_u64(224);
     let __v_31: G = G::from_u64(201);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_32]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -49863,7 +50444,7 @@ fn aiur_fn_580(
           return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) });
         }
         let __ret: [G; OUT_580] = [];
-        if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[580].weight(); } record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -49883,15 +50464,16 @@ fn aiur_fn_581(
   unconstrained: bool,
 ) -> Result<[G; OUT_581], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     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_578] = { let __args: [G; IN_578] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = []; 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 { let __r = record.function_queries[578].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -49902,9 +50484,9 @@ fn aiur_fn_581(
     break '__mc_0 [__v_7, __v_8];
   },
   1u64 => {
-    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[379].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -49915,10 +50497,10 @@ fn aiur_fn_581(
     break '__mc_0 [__v_7, __v_8];
   },
   2u64 => {
-    let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = []; 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 { let __r = record.function_queries[580].replay_at(__i); record.virt += __r; } 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_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 { let __r = record.function_queries[380].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -49929,9 +50511,9 @@ fn aiur_fn_581(
     break '__mc_0 [__v_7, __v_8];
   },
   3u64 => {
-    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[381].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_6: G = G::from_u64(1);
     if (__v_5 != __v_6) {
@@ -49952,14 +50534,14 @@ fn aiur_fn_581(
       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_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_5, __v_6]; 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 { let __r = record.function_queries[579].replay_at(__i); record.virt += __r; } 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 __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_581] = [];
-    if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[581].weight(); } record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -49974,16 +50556,17 @@ fn aiur_fn_582(
   unconstrained: bool,
 ) -> Result<[G; OUT_582], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_582] = [__v_0];
-        if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[582].weight(); } record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -49992,10 +50575,10 @@ fn aiur_fn_582(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_7]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __ret: [G; OUT_582] = [__v_8];
-            if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[582].weight(); } record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -50017,29 +50600,30 @@ fn aiur_fn_583(
   unconstrained: bool,
 ) -> Result<[G; OUT_583], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_583] = [];
-        if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[583].weight(); } record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_6: G = __loaded[0];
             let __v_7: G = __loaded[1];
             let __v_8: G = __loaded[2];
@@ -50049,12 +50633,12 @@ fn aiur_fn_583(
                 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_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_5, __v_10, __v_12]; 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 { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } 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)? } };
                 if (__v_7 != __v_2) {
                   return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) });
                 }
                 let __ret: [G; OUT_583] = [];
-                if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[583].weight(); } record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -50081,6 +50665,7 @@ fn aiur_fn_584(
   unconstrained: bool,
 ) -> Result<[G; OUT_584], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -50089,17 +50674,17 @@ fn aiur_fn_584(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_584] = [];
-        if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[584].weight(); } record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -50108,7 +50693,7 @@ fn aiur_fn_584(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = (__v_3 + __v_12);
-                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_13]; 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 { let __r = record.function_queries[584].replay_at(__i); record.virt += __r; } 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_14: G = (__v_2 + __v_1);
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = (__v_14 - __v_15);
@@ -50117,7 +50702,7 @@ fn aiur_fn_584(
                   return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) });
                 }
                 let __ret: [G; OUT_584] = [];
-                if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[584].weight(); } record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -50144,12 +50729,13 @@ fn aiur_fn_585(
   unconstrained: bool,
 ) -> Result<[G; OUT_585], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -50164,7 +50750,7 @@ fn aiur_fn_585(
     let __v_15: G = __loaded[11];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_17: G = G::from_u64(1);
         if (__v_16 != __v_17) {
@@ -50174,7 +50760,7 @@ fn aiur_fn_585(
           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_585] = [];
-        if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[585].weight(); } record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -50194,6 +50780,7 @@ fn aiur_fn_586(
   unconstrained: bool,
 ) -> Result<[G; OUT_586], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -50202,44 +50789,44 @@ fn aiur_fn_586(
     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_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_8]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_11: G = __loaded[0];
     let __v_12: G = __loaded[1];
     let __v_13: G = __loaded[2];
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_5, __v_6]; 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 { let __r = record.function_queries[585].replay_at(__i); record.virt += __r; } 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_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_4, __v_15]; 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 { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } 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_16: G = G::from_u64(0);
-        let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_10, __v_1, __v_3, __v_16]; 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 { let __r = record.function_queries[584].replay_at(__i); record.virt += __r; } 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_771] = { let __args: [G; IN_771] = [__v_10, __v_1]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
         let __v_18: G = G::from_u64(0);
         let __v_19: G = G::from_u64(1);
         let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_10]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
         let __v_24: G = (__v_1 + __v_2);
         if (__v_23 != __v_24) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) });
         }
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_17, __v_22]; 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 { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } 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_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_586] = [];
-        if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[586].weight(); } record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -50259,6 +50846,7 @@ fn aiur_fn_587(
   unconstrained: bool,
 ) -> Result<[G; OUT_587], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -50266,37 +50854,37 @@ fn aiur_fn_587(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_587] = [];
-        if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[587].weight(); } record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         let __v_7: G = __loaded[3];
         match __v_4.as_canonical_u64() {
           5u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_9, __v_3]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __v_13: G = G::from_u64(0);
-                let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_15: G = G::from_u64(1);
                 if (__v_12 != __v_15) {
                   return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) });
                 }
                 let __v_16: G = G::from_u64(1);
                 let __v_17: G = (__v_2 - __v_16);
-                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_6, __v_10, __v_17, __v_14]; 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 { let __r = record.function_queries[587].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_587] = [];
-                if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[587].weight(); } record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -50323,15 +50911,16 @@ fn aiur_fn_588(
   unconstrained: bool,
 ) -> Result<[G; OUT_588], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_0, __v_1, __v_2, __v_5]; 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 { let __r = record.function_queries[587].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_588] = [];
-    if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[588].weight(); } record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -50346,14 +50935,15 @@ fn aiur_fn_589(
   unconstrained: bool,
 ) -> Result<[G; OUT_589], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -50361,7 +50951,7 @@ fn aiur_fn_589(
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_589] = [__v_5];
-            if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[589].weight(); } record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -50370,7 +50960,7 @@ fn aiur_fn_589(
         }
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -50380,11 +50970,11 @@ fn aiur_fn_589(
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_9, __v_11]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __ret: [G; OUT_589] = [__v_12];
-            if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[589].weight(); } record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -50406,34 +50996,35 @@ fn aiur_fn_590(
   unconstrained: bool,
 ) -> Result<[G; OUT_590], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_2]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_7, __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 { let __r = record.function_queries[320].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_8 != __v_9) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) });
         }
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_1, __v_11]; 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 { let __r = record.function_queries[590].replay_at(__i); record.virt += __r; } 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] = [];
-        if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[590].weight(); } record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_590] = [];
-        if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[590].weight(); } record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -50450,19 +51041,20 @@ fn aiur_fn_591(
   unconstrained: bool,
 ) -> Result<[G; OUT_591], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[590].replay_at(__i); record.virt += __r; } 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] = [];
-        if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[591].weight(); } record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -50472,10 +51064,10 @@ fn aiur_fn_591(
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_9, __v_2, __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 { let __r = record.function_queries[591].replay_at(__i); record.virt += __r; } 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] = [];
-            if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[591].weight(); } record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -50497,26 +51089,27 @@ fn aiur_fn_592(
   unconstrained: bool,
 ) -> Result<[G; OUT_592], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_592] = [];
-        if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[592].weight(); } record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __v_8: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_8]; 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 { let __r = record.function_queries[591].replay_at(__i); record.virt += __r; } 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_592] = [];
-        if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[592].weight(); } record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -50533,12 +51126,13 @@ fn aiur_fn_593(
   unconstrained: bool,
 ) -> Result<[G; OUT_593], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1]; 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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __ret: [G; OUT_593] = [__v_2];
-    if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[593].weight(); } record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -50553,9 +51147,10 @@ fn aiur_fn_594(
   unconstrained: bool,
 ) -> Result<[G; OUT_594], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -50563,24 +51158,24 @@ fn aiur_fn_594(
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_594] = [__v_5];
-        if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
             let __ret: [G; OUT_594] = [__v_6];
-            if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_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 { let __r = record.function_queries[594].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
             let __ret: [G; OUT_594] = [__v_6];
-            if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[594].weight(); } record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -50602,11 +51197,12 @@ fn aiur_fn_595(
   unconstrained: bool,
 ) -> Result<[G; OUT_595], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -50621,16 +51217,16 @@ fn aiur_fn_595(
     let __v_14: G = __loaded[11];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_1, __v_10]; 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 { let __r = record.function_queries[594].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
         let __ret: [G; OUT_595] = [__v_15];
-        if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[595].weight(); } record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_15: G = G::from_u64(0);
         let __ret: [G; OUT_595] = [__v_15];
-        if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[595].weight(); } record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -50647,9 +51243,10 @@ fn aiur_fn_596(
   unconstrained: bool,
 ) -> Result<[G; OUT_596], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -50658,104 +51255,104 @@ fn aiur_fn_596(
       0u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_596] = [__v_6];
-        if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_596] = [__v_6];
-        if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_3, __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 { let __r = record.function_queries[595].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __ret: [G; OUT_596] = [__v_6];
-        if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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 = __r_arr[0];
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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 = __r_arr[0];
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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 = __r_arr[0];
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __ret: [G; OUT_596] = [__v_7];
-            if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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 = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
                 let __ret: [G; OUT_596] = [__v_8];
-                if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
                 let __ret: [G; OUT_596] = [__v_8];
-                if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -50765,14 +51362,14 @@ fn aiur_fn_596(
       7u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_596] = [__v_6];
-        if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_596] = [__v_6];
-        if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[596].weight(); } record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -50792,9 +51389,10 @@ fn aiur_fn_597(
   unconstrained: bool,
 ) -> Result<[G; OUT_597], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -50802,24 +51400,24 @@ fn aiur_fn_597(
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_597] = [__v_5];
-        if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
             let __ret: [G; OUT_597] = [__v_6];
-            if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_1]; 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 { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __ret: [G; OUT_597] = [__v_6];
-            if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[597].weight(); } record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -50841,17 +51439,18 @@ fn aiur_fn_598(
   unconstrained: bool,
 ) -> Result<[G; OUT_598], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_598] = [__v_0, __v_2];
-        if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
@@ -50859,19 +51458,19 @@ fn aiur_fn_598(
         match __v_3.as_canonical_u64() {
           5u64 => {
             let __v_7: G = G::from_u64(0);
-            let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 - __v_9);
-            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_8]; 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 { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             let __ret: [G; OUT_598] = [__v_11, __v_12];
-            if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_598] = [__v_0, __v_2];
-            if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[598].weight(); } record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -50890,6 +51489,7 @@ fn aiur_fn_599(
   unconstrained: bool,
 ) -> Result<[G; OUT_599], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -50898,17 +51498,17 @@ fn aiur_fn_599(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_599] = [];
-        if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[599].weight(); } record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_9: G = __loaded[1];
             let __v_10: G = __loaded[2];
@@ -50923,9 +51523,9 @@ fn aiur_fn_599(
                 }
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = (__v_3 + __v_15);
-                let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_16]; 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 { let __r = record.function_queries[599].replay_at(__i); record.virt += __r; } 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] = [];
-                if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[599].weight(); } record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -50952,14 +51552,15 @@ fn aiur_fn_600(
   unconstrained: bool,
 ) -> Result<[G; OUT_600], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_7: G = __loaded[1];
     let __v_8: G = __loaded[2];
@@ -50975,25 +51576,25 @@ fn aiur_fn_600(
     match __v_6.as_canonical_u64() {
       5u64 => {
         let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_1, __v_7, __v_18]; 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 { let __r = record.function_queries[583].replay_at(__i); record.virt += __r; } 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_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_9, __v_4, __v_19]; 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 { let __r = record.function_queries[599].replay_at(__i); record.virt += __r; } 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_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_20: G = __r_arr[0];
         let __v_21: G = (__v_9 + __v_10);
         if (__v_20 != __v_21) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) });
         }
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_2, __v_9]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_22, __v_3]; 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 { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } 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_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_600] = [];
-        if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[600].weight(); } record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -51013,22 +51614,23 @@ fn aiur_fn_601(
   unconstrained: bool,
 ) -> Result<[G; OUT_601], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_596] = { let __args: [G; IN_596] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_0, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_601] = [];
-        if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_2]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -51036,53 +51638,53 @@ fn aiur_fn_601(
         match __v_6.as_canonical_u64() {
           5u64 => {
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_7, __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 { let __r = record.function_queries[596].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(0);
             if (__v_12 != __v_13) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) });
             }
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_8, __v_1, __v_11, __v_3]; 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 { let __r = record.function_queries[601].replay_at(__i); record.virt += __r; } 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_601] = [];
-            if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_13: G = __loaded[1];
             let __v_14: G = __loaded[2];
             let __v_15: G = __loaded[3];
             match __v_12.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_13, __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 { let __r = record.function_queries[595].replay_at(__i); record.virt += __r; } 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 __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_760] = { let __args: [G; IN_760] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_2]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_13, __v_14, __v_11, __v_1, __v_17]; 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 { let __r = record.function_queries[600].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_601] = [];
-                        if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __ret: [G; OUT_601] = [];
-                        if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                     let __v_19: G = __loaded[1];
                     let __v_20: G = __loaded[2];
@@ -51097,24 +51699,24 @@ fn aiur_fn_601(
                     let __v_29: G = __loaded[11];
                     match __v_18.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_11, __v_21]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_30: G = __r_arr[0];
                         let __v_31: G = G::from_u64(0);
-                        let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+                        let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11, __v_21]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_33: G = __r_arr[0];
-                        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_33]; 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 { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } 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 __v_34: G = __r_arr[0];
-                        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_30, __v_1]; 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 { let __r = record.function_queries[597].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
                         let __v_36: G = G::from_u64(0);
                         if (__v_35 != __v_36) {
                           return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) });
                         }
                         let __v_37: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; 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 { let __r = record.function_queries[602].replay_at(__i); record.virt += __r; } 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_601] = [];
-                        if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[601].weight(); } record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -51145,6 +51747,7 @@ fn aiur_fn_602(
   unconstrained: bool,
 ) -> Result<[G; OUT_602], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51156,13 +51759,13 @@ fn aiur_fn_602(
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_602] = [];
-        if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[602].weight(); } record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -51179,23 +51782,23 @@ fn aiur_fn_602(
           6u64 => {
             let __v_21: G = G::from_u64(1);
             let __v_22: G = G::from_u64(1);
-            let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_11, __v_5, __v_23]; 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 { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } 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_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_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_24, __v_6, __v_26]; 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 { let __r = record.function_queries[368].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_30: G = { let __values: [G; 3] = [__v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_27, __v_3, __v_30, __v_31]; 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 { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } 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 __v_32: G = G::from_u64(1);
             let __v_33: G = (__v_4 + __v_32);
-            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; 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 { let __r = record.function_queries[602].replay_at(__i); record.virt += __r; } 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] = [];
-            if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[602].weight(); } record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -51217,28 +51820,29 @@ fn aiur_fn_603(
   unconstrained: bool,
 ) -> Result<[G; OUT_603], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_5, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[601].replay_at(__i); record.virt += __r; } 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 __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_1, __v_9, __v_3]; 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 { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } 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] = [];
-        if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[603].weight(); } record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_603] = [];
-        if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[603].weight(); } record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -51255,6 +51859,7 @@ fn aiur_fn_604(
   unconstrained: bool,
 ) -> Result<[G; OUT_604], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51262,15 +51867,15 @@ fn aiur_fn_604(
     let __v_4: G = G::from_u64(0);
     let __v_5: G = G::from_u64(1);
     let __v_6: G = G::from_u64(1);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_1, __v_3]; 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 { let __r = record.function_queries[598].replay_at(__i); record.virt += __r; } 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_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_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_8, __v_10, __v_11]; 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 { let __r = record.function_queries[603].replay_at(__i); record.virt += __r; } 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_604] = [];
-    if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[604].weight(); } record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -51285,6 +51890,7 @@ fn aiur_fn_605(
   unconstrained: bool,
 ) -> Result<[G; OUT_605], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51296,13 +51902,13 @@ fn aiur_fn_605(
     let __v_8: G = (__v_1 + __v_2);
     let __v_9: G = G::from_u64(1);
     let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+    let __v_11: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_8, __v_11]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(0);
-    let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__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[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[606].replay_at(__i); record.virt += __r; } 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_605] = [];
-    if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[605].weight(); } record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -51317,6 +51923,7 @@ fn aiur_fn_606(
   unconstrained: bool,
 ) -> Result<[G; OUT_606], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51331,13 +51938,13 @@ fn aiur_fn_606(
     match __v_10.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_606] = [];
-        if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[606].weight(); } record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_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))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -51352,15 +51959,15 @@ fn aiur_fn_606(
         let __v_23: G = __loaded[11];
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_0, __v_14, __v_1]; 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 { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } 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_586] = { let __args: [G; IN_586] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[586].replay_at(__i); record.virt += __r; } 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_592] = { let __args: [G; IN_592] = [__v_14, __v_18, __v_7]; 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 { let __r = record.function_queries[592].replay_at(__i); record.virt += __r; } 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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() {
   0u64 => {
     let __v_24: G = G::from_u64(1);
     let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_14, __v_18, __v_5, __v_26]; 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 { let __r = record.function_queries[604].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -51368,7 +51975,7 @@ fn aiur_fn_606(
   },
 }
  };
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
             let __v_25: G = G::from_u64(1);
             if (__v_24 != __v_25) {
@@ -51385,9 +51992,9 @@ fn aiur_fn_606(
             }
             let __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__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[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[606].replay_at(__i); record.virt += __r; } 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] = [];
-            if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[606].weight(); } record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -51409,6 +52016,7 @@ fn aiur_fn_607(
   unconstrained: bool,
 ) -> Result<[G; OUT_607], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51423,14 +52031,14 @@ fn aiur_fn_607(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __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 { let __r = record.function_queries[605].replay_at(__i); record.virt += __r; } 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_607] = [];
-        if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[607].weight(); } record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_607] = [];
-        if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[607].weight(); } record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -51447,6 +52055,7 @@ fn aiur_fn_608(
   unconstrained: bool,
 ) -> Result<[G; OUT_608], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51462,16 +52071,16 @@ fn aiur_fn_608(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __ret: [G; OUT_608] = [];
-            if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_7]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
@@ -51525,14 +52134,14 @@ fn aiur_fn_608(
                 match __v_14.as_canonical_u64() {
                   8u64 => {
                     let __v_62: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; 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 { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_608] = [];
-                    if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __ret: [G; OUT_608] = [];
-                    if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -51543,7 +52152,7 @@ fn aiur_fn_608(
       },
       _ => {
         let __ret: [G; OUT_608] = [];
-        if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[608].weight(); } record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -51560,6 +52169,7 @@ fn aiur_fn_609(
   unconstrained: bool,
 ) -> Result<[G; OUT_609], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51567,7 +52177,7 @@ fn aiur_fn_609(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -51618,7 +52228,7 @@ fn aiur_fn_609(
     match __v_7.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_609] = [];
-        if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -51630,15 +52240,15 @@ fn aiur_fn_609(
               1u64 => {
                 let __v_56: G = G::from_u64(1);
                 let __v_57: G = (__v_5 + __v_56);
-                let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; 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 { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_609] = [];
-                if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_6, __v_5]; 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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_58: G = __loaded[1];
                 let __v_59: G = __loaded[2];
@@ -51653,23 +52263,23 @@ fn aiur_fn_609(
                 let __v_68: G = __loaded[11];
                 match __v_57.as_canonical_u64() {
                   5u64 => {
-                    let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_1, __v_59, __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 { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } 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_69: G = (__v_2 + __v_3);
                     let __v_70: G = G::from_u64(1);
                     let __v_71: G = G::from_u64(1);
-                    let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+                    let __v_72: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_1, __v_69, __v_72]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
                     let __v_74: G = (__v_60 + __v_61);
                     let __v_75: G = G::from_u64(1);
                     let __v_76: G = G::from_u64(1);
-                    let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+                    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_59, __v_74, __v_77]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
                     if (__v_60 != __v_2) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
                     }
-                    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_73, __v_78]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
                     let __v_80: G = G::from_u64(1);
                     if (__v_79 != __v_80) {
@@ -51677,17 +52287,17 @@ fn aiur_fn_609(
                     }
                     let __v_81: G = G::from_u64(1);
                     let __v_82: G = (__v_5 + __v_81);
-                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; 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 { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_609] = [];
-                    if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_69: G = G::from_u64(1);
                     let __v_70: G = (__v_5 + __v_69);
-                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; 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 { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_609] = [];
-                    if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -51697,9 +52307,9 @@ fn aiur_fn_609(
           _ => {
             let __v_54: G = G::from_u64(1);
             let __v_55: G = (__v_5 + __v_54);
-            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; 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 { let __r = record.function_queries[609].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_609] = [];
-            if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[609].weight(); } record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -51721,6 +52331,7 @@ fn aiur_fn_610(
   unconstrained: bool,
 ) -> Result<[G; OUT_610], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51737,13 +52348,13 @@ fn aiur_fn_610(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0]; 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 { let __r = record.function_queries[294].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     match __v_16.as_canonical_u64() {
       1u64 => {
         let __v_17: G = G::from_u64(1);
         let __ret: [G; OUT_610] = [__v_17];
-        if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -51751,7 +52362,7 @@ fn aiur_fn_610(
           0u64 => {
             let __v_17: G = G::from_u64(0);
             let __ret: [G; OUT_610] = [__v_17];
-            if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -51759,7 +52370,7 @@ fn aiur_fn_610(
               0u64 => {
                 let __v_17: G = G::from_u64(1);
                 let __ret: [G; OUT_610] = [__v_17];
-                if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
@@ -51767,7 +52378,7 @@ fn aiur_fn_610(
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
                     let __ret: [G; OUT_610] = [__v_17];
-                    if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -51777,17 +52388,17 @@ fn aiur_fn_610(
                           0u64 => {
                             let __v_17: G = G::from_u64(1);
                             let __ret: [G; OUT_610] = [__v_17];
-                            if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
+                            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_9, __v_10, __v_19]; 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 { let __r = record.function_queries[611].replay_at(__i); record.virt += __r; } 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 __v_20: G = __r_arr[0];
                             let __ret: [G; OUT_610] = [__v_20];
-                            if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -51795,7 +52406,7 @@ fn aiur_fn_610(
                       _ => {
                         let __v_17: G = G::from_u64(0);
                         let __ret: [G; OUT_610] = [__v_17];
-                        if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -51805,7 +52416,7 @@ fn aiur_fn_610(
               _ => {
                 let __v_17: G = G::from_u64(0);
                 let __ret: [G; OUT_610] = [__v_17];
-                if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[610].weight(); } record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -51826,6 +52437,7 @@ fn aiur_fn_611(
   unconstrained: bool,
 ) -> Result<[G; OUT_611], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51835,15 +52447,15 @@ fn aiur_fn_611(
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_2, __v_4, __v_3, __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 { let __r = record.function_queries[612].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __ret: [G; OUT_611] = [__v_8];
-        if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -51851,19 +52463,19 @@ fn aiur_fn_611(
         match __v_4.as_canonical_u64() {
           5u64 => {
             let __v_8: G = G::from_u64(0);
-            let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_1 - __v_10);
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_11, __v_2, __v_9]; 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 { let __r = record.function_queries[611].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
             let __ret: [G; OUT_611] = [__v_12];
-            if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_611] = [__v_8];
-            if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[611].weight(); } record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -51882,6 +52494,7 @@ fn aiur_fn_612(
   unconstrained: bool,
 ) -> Result<[G; OUT_612], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -51890,30 +52503,30 @@ fn aiur_fn_612(
     let __v_5: G = (__v_1 - __v_2);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_7]; 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 { let __r = record.function_queries[613].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __ret: [G; OUT_612] = [__v_8];
-        if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_10, __v_14]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __v_16: G = (__v_11 - __v_15);
             let __v_17: G = G::from_u64(1);
@@ -51925,26 +52538,26 @@ fn aiur_fn_612(
   },
   _ => {
     let __v_20: G = G::from_u64(0);
-    let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_0 [__v_21];
   },
 }
  };
             let __v_20: G = __mc_out___mc_0[0];
             let __v_21: G = G::from_u64(0);
-            let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_23: G = G::from_u64(1);
             let __v_24: G = (__v_2 + __v_23);
-            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_8, __v_1, __v_24, __v_22, __v_20]; 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 { let __r = record.function_queries[612].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
             let __ret: [G; OUT_612] = [__v_25];
-            if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
             let __ret: [G; OUT_612] = [__v_10];
-            if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[612].weight(); } record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -51963,9 +52576,10 @@ fn aiur_fn_613(
   unconstrained: bool,
 ) -> Result<[G; OUT_613], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -51973,24 +52587,24 @@ fn aiur_fn_613(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __ret: [G; OUT_613] = [__v_5];
-        if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_3]; 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 { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(0);
             let __ret: [G; OUT_613] = [__v_6];
-            if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_4, __v_1]; 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 { let __r = record.function_queries[613].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
             let __ret: [G; OUT_613] = [__v_6];
-            if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[613].weight(); } record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52012,9 +52626,10 @@ fn aiur_fn_614(
   unconstrained: bool,
 ) -> Result<[G; OUT_614], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -52022,11 +52637,11 @@ fn aiur_fn_614(
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_614] = [__v_5];
-        if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -52038,23 +52653,23 @@ fn aiur_fn_614(
               0u64 => {
                 let __v_10: G = G::from_u64(1);
                 let __ret: [G; OUT_614] = [__v_10];
-                if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
                 let __ret: [G; OUT_614] = [__v_10];
-                if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[614].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_614] = [__v_9];
-            if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[614].weight(); } record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52076,6 +52691,7 @@ fn aiur_fn_615(
   unconstrained: bool,
 ) -> Result<[G; OUT_615], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -52091,41 +52707,41 @@ fn aiur_fn_615(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_12]; 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 { let __r = record.function_queries[616].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
             let __v_14: G = G::from_u64(0);
             let __ret: [G; OUT_615] = [__v_14];
-            if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_14: G = (__v_3 + __v_4);
             let __v_15: G = G::from_u64(1);
             let __v_16: G = G::from_u64(1);
-            let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_14, __v_17]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __v_19: G = G::from_u64(0);
             let __v_20: G = G::from_u64(0);
-            let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_18, __v_21]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
                 let __ret: [G; OUT_615] = [__v_23];
-                if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 match __v_5.as_canonical_u64() {
                   1u64 => {
                     let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7, __v_8, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-                    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                     let __v_26: G = __loaded[1];
                     let __v_27: G = __loaded[2];
@@ -52142,13 +52758,13 @@ fn aiur_fn_615(
                       6u64 => {
                         let __v_37: G = G::from_bool((__v_32 == G::ZERO));
                         let __ret: [G; OUT_615] = [__v_37];
-                        if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_37: G = G::from_u64(0);
                         let __ret: [G; OUT_615] = [__v_37];
-                        if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -52156,7 +52772,7 @@ fn aiur_fn_615(
                   _ => {
                     let __v_23: G = G::from_u64(0);
                     let __ret: [G; OUT_615] = [__v_23];
-                    if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -52168,7 +52784,7 @@ fn aiur_fn_615(
       _ => {
         let __v_13: G = G::from_u64(0);
         let __ret: [G; OUT_615] = [__v_13];
-        if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[615].weight(); } record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -52185,19 +52801,20 @@ fn aiur_fn_616(
   unconstrained: bool,
 ) -> Result<[G; OUT_616], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_616] = [__v_3];
-        if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
@@ -52251,16 +52868,16 @@ fn aiur_fn_616(
             match __v_3.as_canonical_u64() {
               8u64 => {
                 let __v_51: G = G::from_u64(0);
-                let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_51]; 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 { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
                 let __ret: [G; OUT_616] = [__v_52];
-                if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_51: G = G::from_u64(0);
                 let __ret: [G; OUT_616] = [__v_51];
-                if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[616].weight(); } record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -52281,8 +52898,9 @@ fn aiur_fn_617(
   unconstrained: bool,
 ) -> Result<[G; OUT_617], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -52337,13 +52955,13 @@ fn aiur_fn_617(
           8u64 => {
             let __v_49: G = G::from_u64(1);
             let __ret: [G; OUT_617] = [__v_49];
-            if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[617].weight(); } record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
             let __ret: [G; OUT_617] = [__v_49];
-            if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[617].weight(); } record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52362,9 +52980,10 @@ fn aiur_fn_618(
   unconstrained: bool,
 ) -> Result<[G; OUT_618], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -52418,13 +53037,13 @@ fn aiur_fn_618(
           1u64 => {
             let __v_49: G = G::from_u64(1);
             let __ret: [G; OUT_618] = [__v_49];
-            if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
             let __ret: [G; OUT_618] = [__v_49];
-            if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52434,17 +53053,17 @@ fn aiur_fn_618(
           1u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_50]; 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 { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __ret: [G; OUT_618] = [__v_51];
-            if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_48, __v_1]; 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 { let __r = record.function_queries[618].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
             let __ret: [G; OUT_618] = [__v_49];
-            if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[618].weight(); } record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52466,6 +53085,7 @@ fn aiur_fn_619(
   unconstrained: bool,
 ) -> Result<[G; OUT_619], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -52474,19 +53094,19 @@ fn aiur_fn_619(
     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_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_7]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_16: G = __loaded[1];
         let __v_17: G = __loaded[2];
@@ -52494,7 +53114,7 @@ fn aiur_fn_619(
         match __v_15.as_canonical_u64() {
           2u64 => {
             let __ret: [G; OUT_619] = [__v_16];
-            if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[619].weight(); } record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -52519,6 +53139,7 @@ fn aiur_fn_620(
   unconstrained: bool,
 ) -> Result<[G; OUT_620], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -52536,19 +53157,19 @@ fn aiur_fn_620(
         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_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_14]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_17: G = __loaded[1];
         let __v_18: G = __loaded[2];
         let __v_19: G = __loaded[3];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_17]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_23: G = __loaded[1];
             let __v_24: G = __loaded[2];
@@ -52556,15 +53177,15 @@ fn aiur_fn_620(
             match __v_22.as_canonical_u64() {
               2u64 => {
                 let __ret: [G; OUT_620] = [__v_24];
-                if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_26: G = G::from_u64(1);
                 let __v_27: G = G::from_u64(1);
-                let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_620] = [__v_28];
-                if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -52572,9 +53193,9 @@ fn aiur_fn_620(
           _ => {
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(1);
-            let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_620] = [__v_22];
-            if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -52582,9 +53203,9 @@ fn aiur_fn_620(
       _ => {
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_620] = [__v_14];
-        if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[620].weight(); } record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -52601,6 +53222,7 @@ fn aiur_fn_621(
   unconstrained: bool,
 ) -> Result<[G; OUT_621], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -52610,26 +53232,26 @@ fn aiur_fn_621(
     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_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_11: G = __loaded[1];
     let __v_12: G = __loaded[2];
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15, __v_5]; 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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __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_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_16, __v_18]; 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 { let __r = record.function_queries[622].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
         let __ret: [G; OUT_621] = [__v_19];
-        if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[621].weight(); } record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -52649,9 +53271,10 @@ fn aiur_fn_622(
   unconstrained: bool,
 ) -> Result<[G; OUT_622], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -52659,14 +53282,14 @@ fn aiur_fn_622(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_622] = [__v_7];
-        if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[622].weight(); } record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_5, __v_1]; 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 { let __r = record.function_queries[343].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
         if (__v_6 != __v_7) {
@@ -52674,13 +53297,13 @@ fn aiur_fn_622(
         }
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1, __v_9]; 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 { let __r = record.function_queries[359].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_1]; 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 { let __r = record.function_queries[622].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_622] = [__v_12];
-        if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[622].weight(); } record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -52700,6 +53323,7 @@ fn aiur_fn_623(
   unconstrained: bool,
 ) -> Result<[G; OUT_623], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -52708,9 +53332,9 @@ fn aiur_fn_623(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_623] = [__v_6];
-        if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[623].weight(); } record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -52718,14 +53342,14 @@ fn aiur_fn_623(
         let __v_5: G = G::from_u64(4);
         let __v_6: G = (__v_0 + __v_2);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_10]; 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 { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_623] = [__v_12];
-        if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[623].weight(); } record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -52742,9 +53366,10 @@ fn aiur_fn_624(
   unconstrained: bool,
 ) -> Result<[G; OUT_624], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -52798,16 +53423,16 @@ fn aiur_fn_624(
         match __v_2.as_canonical_u64() {
           8u64 => {
             let __v_50: G = G::from_u64(0);
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_3, __v_3, __v_0, __v_1, __v_50]; 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 { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } 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 __v_51: G = __r_arr[0];
             let __ret: [G; OUT_624] = [__v_51];
-            if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_52: G = __loaded[1];
             let __v_53: G = __loaded[2];
@@ -52823,27 +53448,27 @@ fn aiur_fn_624(
             match __v_51.as_canonical_u64() {
               5u64 => {
                 let __v_63: G = G::from_u64(0);
-                let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_1, __v_52, __v_63]; 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 { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
                 let __v_65: G = G::from_u64(0);
                 let __v_66: G = G::from_u64(0);
                 let __v_67: G = G::from_u64(1);
                 let __v_68: G = G::from_u64(1);
-                let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_70: G = G::from_u64(1);
                 let __v_71: G = G::from_u64(1);
-                let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_624] = [__v_73];
-                if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_63: G = G::from_u64(1);
                 let __v_64: G = G::from_u64(1);
-                let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_624] = [__v_65];
-                if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[624].weight(); } record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -52864,12 +53489,13 @@ fn aiur_fn_625(
   unconstrained: bool,
 ) -> Result<[G; OUT_625], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -52921,19 +53547,19 @@ fn aiur_fn_625(
       1u64 => {
         let __v_52: G = G::from_u64(1);
         let __v_53: G = G::from_u64(1);
-        let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_625] = [__v_54];
-        if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_4]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_4]; 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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_55: G = __loaded[1];
             let __v_56: G = __loaded[2];
@@ -52958,29 +53584,29 @@ fn aiur_fn_625(
  };
             let __v_66: G = __mc_out___mc_0[0];
             let __v_67: G = G::from_u64(0);
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_3, __v_66, __v_67]; 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 { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } 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_68: G = __r_arr[0];
             let __v_69: G = G::from_u64(0);
             let __v_70: G = G::from_u64(0);
             let __v_71: G = G::from_u64(1);
             let __v_72: G = G::from_u64(1);
-            let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_74: G = G::from_u64(1);
             let __v_75: G = (__v_4 + __v_74);
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_75]; 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 { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } 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 __v_76: G = __r_arr[0];
-            let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_625] = [__v_77];
-            if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_52: G = G::from_u64(1);
             let __v_53: G = (__v_4 + __v_52);
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_0, __v_51, __v_2, __v_3, __v_53]; 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 { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } 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 __v_54: G = __r_arr[0];
             let __ret: [G; OUT_625] = [__v_54];
-            if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[625].weight(); } record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -53002,10 +53628,11 @@ fn aiur_fn_626(
   unconstrained: bool,
 ) -> Result<[G; OUT_626], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -53016,48 +53643,48 @@ fn aiur_fn_626(
       1u64 => {
         let __v_9: G = G::from_u64(0);
         let __ret: [G; OUT_626] = [__v_9];
-        if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_6, __v_2]; 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 { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } 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 __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_626] = [__v_11];
-                    if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; 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 { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
                     let __ret: [G; OUT_626] = [__v_11];
-                    if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; 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 { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
                 let __ret: [G; OUT_626] = [__v_10];
-                if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_1, __v_2]; 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 { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
             let __ret: [G; OUT_626] = [__v_9];
-            if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[626].weight(); } record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -53079,6 +53706,7 @@ fn aiur_fn_627(
   unconstrained: bool,
 ) -> Result<[G; OUT_627], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = (__v_0 - __v_1);
@@ -53086,18 +53714,18 @@ fn aiur_fn_627(
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_627] = [__v_3];
-        if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
         let __v_6: G = __loaded[3];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
@@ -53109,13 +53737,13 @@ fn aiur_fn_627(
                   0u64 => {
                     let __v_12: G = G::from_u64(1);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53123,55 +53751,55 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           1u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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];
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_5, __v_9]; 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 { let __r = record.function_queries[628].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53179,33 +53807,33 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53213,33 +53841,33 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               4u64 => {
-                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53247,33 +53875,33 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           5u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53281,37 +53909,37 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           6u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_4, __v_8]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_5, __v_9]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
                     match __v_12.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
                         let __ret: [G; OUT_627] = [__v_13];
-                        if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
                         let __ret: [G; OUT_627] = [__v_13];
-                        if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -53319,7 +53947,7 @@ fn aiur_fn_627(
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53327,58 +53955,58 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           7u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5, __v_8, __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 { let __r = record.function_queries[337].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           8u64 => {
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_12: G = (__v_5 - __v_9);
                     match __v_12.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_6, __v_10]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
                         let __ret: [G; OUT_627] = [__v_13];
-                        if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
                         let __ret: [G; OUT_627] = [__v_13];
-                        if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -53386,7 +54014,7 @@ fn aiur_fn_627(
                   _ => {
                     let __v_12: G = G::from_u64(0);
                     let __ret: [G; OUT_627] = [__v_12];
-                    if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -53394,7 +54022,7 @@ fn aiur_fn_627(
               _ => {
                 let __v_11: G = G::from_u64(0);
                 let __ret: [G; OUT_627] = [__v_11];
-                if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[627].weight(); } record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -53418,15 +54046,16 @@ fn aiur_fn_628(
   unconstrained: bool,
 ) -> Result<[G; OUT_628], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -53434,19 +54063,19 @@ fn aiur_fn_628(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_628] = [__v_8];
-            if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_628] = [__v_8];
-            if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -53454,24 +54083,24 @@ fn aiur_fn_628(
           1u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_628] = [__v_8];
-            if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[324].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_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 { let __r = record.function_queries[628].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
                 let __ret: [G; OUT_628] = [__v_9];
-                if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
                 let __ret: [G; OUT_628] = [__v_9];
-                if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[628].weight(); } record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -53498,15 +54127,16 @@ fn aiur_fn_629(
   unconstrained: bool,
 ) -> Result<[G; OUT_629], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -53514,19 +54144,19 @@ fn aiur_fn_629(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __ret: [G; OUT_629] = [__v_8];
-            if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_629] = [__v_8];
-            if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
@@ -53534,24 +54164,24 @@ fn aiur_fn_629(
           1u64 => {
             let __v_8: G = G::from_u64(0);
             let __ret: [G; OUT_629] = [__v_8];
-            if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_6]; 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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __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 { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[0];
                 let __ret: [G; OUT_629] = [__v_9];
-                if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
                 let __ret: [G; OUT_629] = [__v_9];
-                if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[629].weight(); } record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -53578,6 +54208,7 @@ fn aiur_fn_630(
   unconstrained: bool,
 ) -> Result<[G; OUT_630], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -53593,18 +54224,18 @@ fn aiur_fn_630(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; 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 { let __r = record.function_queries[621].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __ret: [G; OUT_630] = [__v_13];
-        if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[630].weight(); } record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(1);
         let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_630] = [__v_15];
-        if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[630].weight(); } record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -53621,9 +54252,10 @@ fn aiur_fn_631(
   unconstrained: bool,
 ) -> Result<[G; OUT_631], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = __r_arr[2];
@@ -53677,15 +54309,15 @@ fn aiur_fn_631(
         match __v_2.as_canonical_u64() {
           8u64 => {
             let __v_50: G = G::from_u64(0);
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3, __v_3, __v_0, __v_50, __v_1]; 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 { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
             let __ret: [G; OUT_631] = [__v_51];
-            if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[631].weight(); } record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_631] = [__v_1];
-            if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[631].weight(); } record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -53704,12 +54336,13 @@ fn aiur_fn_632(
   unconstrained: bool,
 ) -> Result<[G; OUT_632], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -53760,17 +54393,17 @@ fn aiur_fn_632(
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_632] = [__v_4];
-        if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_3]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_52]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_55: G = __loaded[1];
             let __v_56: G = __loaded[2];
@@ -53785,11 +54418,11 @@ fn aiur_fn_632(
             let __v_65: G = __loaded[11];
             match __v_54.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_56, __v_57, __v_59, __v_60, __v_58]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_66]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_67: G = __r_arr[0];
-                let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                 let __v_69: G = __loaded[1];
                 let __v_70: G = __loaded[2];
@@ -53805,19 +54438,19 @@ fn aiur_fn_632(
                 match __v_68.as_canonical_u64() {
                   5u64 => {
                     let __ret: [G; OUT_632] = [__v_75];
-                    if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __ret: [G; OUT_632] = [__v_4];
-                    if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __ret: [G; OUT_632] = [__v_4];
-                if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -53825,10 +54458,10 @@ fn aiur_fn_632(
           _ => {
             let __v_52: G = G::from_u64(1);
             let __v_53: G = (__v_3 + __v_52);
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_51, __v_2, __v_53, __v_4]; 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 { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
             let __ret: [G; OUT_632] = [__v_54];
-            if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[632].weight(); } record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -53850,10 +54483,11 @@ fn aiur_fn_633(
   unconstrained: bool,
 ) -> Result<[G; OUT_633], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -53907,7 +54541,7 @@ fn aiur_fn_633(
     match __v_3.as_canonical_u64() {
       8u64 => {
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_4, __v_0, __v_51, __v_1]; 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 { let __r = record.function_queries[632].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
         break '__mc_0 [__v_52];
       },
@@ -53919,7 +54553,7 @@ fn aiur_fn_633(
 }
  };
     let __v_51: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_51]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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];
@@ -53973,14 +54607,14 @@ fn aiur_fn_633(
     match __v_52.as_canonical_u64() {
       8u64 => {
         let __v_100: G = G::from_u64(0);
-        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_53, __v_53, __v_51, __v_2, __v_100]; 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 { let __r = record.function_queries[625].replay_at(__i); record.virt += __r; } 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 __v_101: G = __r_arr[0];
         break '__mc_1 [__v_101];
       },
       _ => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_51]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_100: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_102: G = __loaded[1];
         let __v_103: G = __loaded[2];
@@ -53996,23 +54630,23 @@ fn aiur_fn_633(
         match __v_101.as_canonical_u64() {
           5u64 => {
             let __v_113: G = G::from_u64(0);
-            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_102, __v_113]; 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 { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } 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_114: G = __r_arr[0];
             let __v_115: G = G::from_u64(0);
             let __v_116: G = G::from_u64(0);
             let __v_117: G = G::from_u64(1);
             let __v_118: G = G::from_u64(1);
-            let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_120: G = G::from_u64(1);
             let __v_121: G = G::from_u64(1);
-            let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             break '__mc_1 [__v_123];
           },
           _ => {
             let __v_113: G = G::from_u64(1);
             let __v_114: G = G::from_u64(1);
-            let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             break '__mc_1 [__v_115];
           },
         }
@@ -54022,19 +54656,19 @@ fn aiur_fn_633(
 }
  };
     let __v_100: G = __mc_out___mc_1[0];
-    let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_0]; 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 { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } 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_101: G = __r_arr[0];
     match __v_101.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_633] = [__v_100];
-        if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[633].weight(); } record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_51, __v_2, __v_100]; 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 { let __r = record.function_queries[634].replay_at(__i); record.virt += __r; } 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_102: G = __r_arr[0];
         let __ret: [G; OUT_633] = [__v_102];
-        if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[633].weight(); } record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -54051,11 +54685,12 @@ fn aiur_fn_634(
   unconstrained: bool,
 ) -> Result<[G; OUT_634], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = __r_arr[2];
@@ -54109,15 +54744,15 @@ fn aiur_fn_634(
         match __v_4.as_canonical_u64() {
           8u64 => {
             let __v_52: G = G::from_u64(0);
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; 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 { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
             let __ret: [G; OUT_634] = [__v_53];
-            if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[634].weight(); } record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_634] = [__v_3];
-            if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[634].weight(); } record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54136,6 +54771,7 @@ fn aiur_fn_635(
   unconstrained: bool,
 ) -> Result<[G; OUT_635], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54143,7 +54779,7 @@ fn aiur_fn_635(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -54194,17 +54830,17 @@ fn aiur_fn_635(
     match __v_7.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_635] = [__v_5];
-        if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_6]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_54]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_57: G = __loaded[1];
             let __v_58: G = __loaded[2];
@@ -54219,11 +54855,11 @@ fn aiur_fn_635(
             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_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_58, __v_59, __v_61, __v_62, __v_60]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_68]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_71: G = __loaded[1];
     let __v_72: G = __loaded[2];
@@ -54238,7 +54874,7 @@ fn aiur_fn_635(
     let __v_81: G = __loaded[11];
     match __v_70.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_77, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_82: G = __r_arr[0];
         match __v_82.as_canonical_u64() {
           1u64 => {
@@ -54280,39 +54916,39 @@ fn aiur_fn_635(
               0u64 => {
                 let __v_73: G = G::from_u64(1);
                 let __v_74: G = (__v_6 + __v_73);
-                let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; 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 { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
                 let __ret: [G; OUT_635] = [__v_75];
-                if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__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[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[630].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
-                let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__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[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[620].replay_at(__i); record.virt += __r; } 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 __v_74: G = __r_arr[0];
-                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_69, __v_73]; 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 { let __r = record.function_queries[626].replay_at(__i); record.virt += __r; } 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 __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_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; 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 { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
                     let __ret: [G; OUT_635] = [__v_78];
-                    if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_76: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_5, __v_69, __v_76, __v_73, __v_74]; 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 { let __r = record.function_queries[769].replay_at(__i); record.virt += __r; } 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 __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_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; 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 { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
                     let __ret: [G; OUT_635] = [__v_80];
-                    if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -54322,10 +54958,10 @@ fn aiur_fn_635(
           _ => {
             let __v_54: G = G::from_u64(1);
             let __v_55: G = (__v_6 + __v_54);
-            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; 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 { let __r = record.function_queries[635].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
             let __ret: [G; OUT_635] = [__v_56];
-            if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[635].weight(); } record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54347,10 +54983,11 @@ fn aiur_fn_636(
   unconstrained: bool,
 ) -> Result<[G; OUT_636], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -54362,27 +54999,27 @@ fn aiur_fn_636(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __ret: [G; OUT_636] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_10: G = G::from_u64(1);
             let __ret: [G; OUT_636] = [__v_10, __v_2];
-            if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_2 + __v_10);
-            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_11]; 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 { let __r = record.function_queries[636].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             let __ret: [G; OUT_636] = [__v_12, __v_13];
-            if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[636].weight(); } record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54404,12 +55041,13 @@ fn aiur_fn_637(
   unconstrained: bool,
 ) -> Result<[G; OUT_637], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -54421,11 +55059,11 @@ fn aiur_fn_637(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_637] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_12: G = (__v_2 - __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() {
@@ -54442,7 +55080,7 @@ fn aiur_fn_637(
         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_629] = { let __args: [G; IN_629] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __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 { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
     break '__mc_1 [__v_14];
   },
@@ -54459,17 +55097,17 @@ fn aiur_fn_637(
           1u64 => {
             let __v_17: G = G::from_u64(1);
             let __ret: [G; OUT_637] = [__v_17, __v_4];
-            if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_17: G = G::from_u64(1);
             let __v_18: G = (__v_4 + __v_17);
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_1, __v_2, __v_3, __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 { let __r = record.function_queries[637].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
             let __ret: [G; OUT_637] = [__v_19, __v_20];
-            if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[637].weight(); } record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54491,9 +55129,10 @@ fn aiur_fn_638(
   unconstrained: bool,
 ) -> Result<[G; OUT_638], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -54534,35 +55173,35 @@ fn aiur_fn_638(
         let __v_37: G = G::from_u64(0);
         let __v_38: G = G::from_u64(0);
         let __v_39: G = G::from_u64(0);
-        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(1);
         let __v_43: G = G::from_u64(1);
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_45: G = G::from_u64(1);
         let __v_46: G = G::from_u64(1);
-        let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_638] = [__v_40, __v_41, __v_44, __v_47];
-        if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_638] = [__v_3, __v_4, __v_5, __v_6];
-            if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_7, __v_9]; 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 { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } 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_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_638] = [__v_10, __v_11, __v_12, __v_13];
-            if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[638].weight(); } record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54584,6 +55223,7 @@ fn aiur_fn_639(
   unconstrained: bool,
 ) -> Result<[G; OUT_639], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54595,21 +55235,21 @@ fn aiur_fn_639(
         let __v_6: G = (__v_1 - __v_5);
         let __v_7: G = (__v_6 - __v_0);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_639] = [__v_9];
-        if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_0]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
             let __ret: [G; OUT_639] = [__v_6];
-            if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -54618,9 +55258,9 @@ fn aiur_fn_639(
             let __v_8: G = (__v_1 - __v_7);
             let __v_9: G = (__v_8 - __v_0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_639] = [__v_11];
-            if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[639].weight(); } record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -54639,6 +55279,7 @@ fn aiur_fn_640(
   unconstrained: bool,
 ) -> Result<[G; OUT_640], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54648,30 +55289,30 @@ fn aiur_fn_640(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_640] = [__v_0];
-        if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[640].weight(); } record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_2, __v_3, __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 { let __r = record.function_queries[639].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_8, __v_10, __v_11]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; 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 { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
             let __ret: [G; OUT_640] = [__v_17];
-            if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[640].weight(); } record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -54693,19 +55334,20 @@ fn aiur_fn_641(
   unconstrained: bool,
 ) -> Result<[G; OUT_641], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_641] = [__v_4];
-        if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -54715,20 +55357,20 @@ fn aiur_fn_641(
             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_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_4, __v_8]; 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 { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_641] = [__v_10];
-            if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_11: G = __loaded[1];
             let __v_12: G = __loaded[2];
@@ -54738,19 +55380,19 @@ fn aiur_fn_641(
                 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_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_12, __v_16]; 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 { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-                let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_641] = [__v_18];
-                if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_641] = [__v_16];
-                if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[641].weight(); } record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -54771,6 +55413,7 @@ fn aiur_fn_642(
   unconstrained: bool,
 ) -> Result<[G; OUT_642], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54779,7 +55422,7 @@ fn aiur_fn_642(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_642] = [__v_0];
-        if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[642].weight(); } record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -54789,16 +55432,16 @@ fn aiur_fn_642(
         let __v_8: G = (__v_7 - __v_3);
         let __v_9: G = (__v_8 + __v_2);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_12: G = G::from_u64(3);
         let __v_13: G = G::from_u64(0);
-        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = (__v_3 + __v_15);
-        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_14, __v_1, __v_2, __v_16]; 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 { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __ret: [G; OUT_642] = [__v_17];
-        if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[642].weight(); } record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -54815,30 +55458,31 @@ fn aiur_fn_643(
   unconstrained: bool,
 ) -> Result<[G; OUT_643], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_643] = [__v_0];
-        if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[643].weight(); } record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_6]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_5, __v_2]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_643] = [__v_11];
-        if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[643].weight(); } record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -54858,6 +55502,7 @@ fn aiur_fn_644(
   unconstrained: bool,
 ) -> Result<[G; OUT_644], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54866,17 +55511,17 @@ fn aiur_fn_644(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1, __v_2, __v_5]; 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 { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_644] = [__v_6];
-        if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[644].weight(); } record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_4, __v_2]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __ret: [G; OUT_644] = [__v_5];
-        if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[644].weight(); } record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -54893,6 +55538,7 @@ fn aiur_fn_645(
   unconstrained: bool,
 ) -> Result<[G; OUT_645], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -54900,7 +55546,7 @@ fn aiur_fn_645(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_645] = [__v_0];
-        if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[645].weight(); } record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -54909,16 +55555,16 @@ fn aiur_fn_645(
         let __v_6: G = (__v_1 - __v_5);
         let __v_7: G = (__v_6 - __v_2);
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_10: G = G::from_u64(3);
         let __v_11: G = G::from_u64(0);
-        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_13: G = G::from_u64(1);
         let __v_14: G = (__v_2 + __v_13);
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_1, __v_14]; 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 { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
         let __ret: [G; OUT_645] = [__v_15];
-        if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[645].weight(); } record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -54935,26 +55581,27 @@ fn aiur_fn_646(
   unconstrained: bool,
 ) -> Result<[G; OUT_646], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_646] = [__v_0];
-        if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[646].weight(); } record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_4]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_646] = [__v_8];
-        if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[646].weight(); } record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -54974,19 +55621,20 @@ fn aiur_fn_647(
   unconstrained: bool,
 ) -> Result<[G; OUT_647], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_647] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -54995,22 +55643,22 @@ fn aiur_fn_647(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __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 { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } 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];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_647] = [__v_11, __v_9];
-            if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
-            let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __v_8: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_8]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_11: G = __loaded[1];
             let __v_12: G = __loaded[2];
@@ -55019,21 +55667,21 @@ fn aiur_fn_647(
               5u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = (__v_1 - __v_14);
-                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_12, __v_15]; 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 { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
                 let __v_17: G = __r_arr[1];
                 let __v_18: G = G::from_u64(0);
-                let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_647] = [__v_19, __v_17];
-                if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_647] = [__v_16, __v_0];
-                if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[647].weight(); } record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -55054,10 +55702,11 @@ fn aiur_fn_648(
   unconstrained: bool,
 ) -> Result<[G; OUT_648], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -55065,22 +55714,22 @@ fn aiur_fn_648(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_648] = [__v_8];
-        if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[648].weight(); } record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_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_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __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 { let __r = record.function_queries[648].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_648] = [__v_11];
-        if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[648].weight(); } record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -55100,6 +55749,7 @@ fn aiur_fn_649(
   unconstrained: bool,
 ) -> Result<[G; OUT_649], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55108,18 +55758,18 @@ fn aiur_fn_649(
     let __v_5: G = inp[5];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_3]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __ret: [G; OUT_649] = [__v_6];
-        if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[649].weight(); } record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1, __v_2, __v_6]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_649] = [__v_7];
-        if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[649].weight(); } record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -55136,6 +55786,7 @@ fn aiur_fn_650(
   unconstrained: bool,
 ) -> Result<[G; OUT_650], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55143,23 +55794,23 @@ fn aiur_fn_650(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_650] = [__v_0];
-        if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[650].weight(); } record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = (__v_1 - __v_2);
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_8: G = G::from_u64(3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_2 + __v_11);
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_10, __v_1, __v_12]; 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 { let __r = record.function_queries[650].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __ret: [G; OUT_650] = [__v_13];
-        if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[650].weight(); } record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -55176,6 +55827,7 @@ fn aiur_fn_651(
   unconstrained: bool,
 ) -> Result<[G; OUT_651], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55185,25 +55837,25 @@ fn aiur_fn_651(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_4]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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];
     let __v_10: G = G::from_u64(0);
-    let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; 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 { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_11, __v_3]; 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 { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(2);
     let __v_14: G = G::from_u64(0);
-    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   0u64 => {
     let __v_16: G = G::from_u64(0);
-    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_15, __v_6, __v_3, __v_16]; 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 { let __r = record.function_queries[642].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
     break '__mc_0 [__v_17];
   },
   _ => {
-    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_15, __v_8, __v_3]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
@@ -55211,18 +55863,18 @@ fn aiur_fn_651(
  };
     let __v_16: G = __mc_out___mc_0[0];
     let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_16, __v_3, __v_17]; 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 { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(0);
-    let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_22: G = G::from_u64(5);
     let __v_23: G = G::from_u64(0);
-    let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_24, __v_12]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
     let __ret: [G; OUT_651] = [__v_25];
-    if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[651].weight(); } record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -55237,14 +55889,15 @@ fn aiur_fn_652(
   unconstrained: bool,
 ) -> Result<[G; OUT_652], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __ret: [G; OUT_652] = [__v_4];
-    if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[652].weight(); } record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -55259,6 +55912,7 @@ fn aiur_fn_653(
   unconstrained: bool,
 ) -> Result<[G; OUT_653], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55267,23 +55921,23 @@ fn aiur_fn_653(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_653] = [__v_0];
-        if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[653].weight(); } record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = (__v_2 - __v_3);
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_9: G = G::from_u64(3);
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_3 + __v_12);
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_11, __v_1, __v_2, __v_13]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __ret: [G; OUT_653] = [__v_14];
-        if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[653].weight(); } record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -55300,26 +55954,27 @@ fn aiur_fn_654(
   unconstrained: bool,
 ) -> Result<[G; OUT_654], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_654] = [__v_0];
-        if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[654].weight(); } record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __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 { let __r = record.function_queries[654].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(0);
-        let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_654] = [__v_8];
-        if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[654].weight(); } record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -55339,6 +55994,7 @@ fn aiur_fn_655(
   unconstrained: bool,
 ) -> Result<[G; OUT_655], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55349,14 +56005,14 @@ fn aiur_fn_655(
     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_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_6, __v_9]; 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 { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } 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_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_283] = { let __args: [G; IN_283] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_10]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_16: G = __loaded[1];
     let __v_17: G = __loaded[2];
@@ -55371,17 +56027,17 @@ fn aiur_fn_655(
     let __v_26: G = __loaded[11];
     match __v_15.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[656].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         let __ret: [G; OUT_655] = [__v_27];
-        if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[655].weight(); } record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__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[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[656].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         let __ret: [G; OUT_655] = [__v_27];
-        if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[655].weight(); } record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -55398,6 +56054,7 @@ fn aiur_fn_656(
   unconstrained: bool,
 ) -> Result<[G; OUT_656], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55409,30 +56066,30 @@ fn aiur_fn_656(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_7, __v_1, __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 { let __r = record.function_queries[623].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_13]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_14, __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 { let __r = record.function_queries[647].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_8, __v_6, __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 { let __r = record.function_queries[652].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_8, __v_9, __v_4, __v_11, __v_4]; 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 { let __r = record.function_queries[670].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_8, __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 { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } 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_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_283] = { let __args: [G; IN_283] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_20]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_26: G = __loaded[1];
     let __v_27: G = __loaded[2];
@@ -55447,20 +56104,20 @@ fn aiur_fn_656(
     let __v_36: G = __loaded[11];
     match __v_25.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_27, __v_23]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
         let __v_38: G = G::from_u64(0);
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; 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 { let __r = record.function_queries[640].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_39, __v_5]; 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 { let __r = record.function_queries[641].replay_at(__i); record.virt += __r; } 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_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_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_40, __v_41, __v_42]; 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 { let __r = record.function_queries[648].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
         let __v_44: G = G::from_u64(2);
         let __v_45: G = G::from_u64(0);
-        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_47: G = (__v_4 + __v_11);
         let __v_48: G = (__v_47 + __v_19);
         let __v_49: G = (__v_48 + __v_5);
@@ -55470,13 +56127,13 @@ fn aiur_fn_656(
         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_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_46, __v_22, __v_53]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
     break '__mc_0 [__v_54];
   },
   _ => {
     let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_4, __v_51, __v_54]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
     break '__mc_0 [__v_55];
   },
@@ -55484,7 +56141,7 @@ fn aiur_fn_656(
  };
         let __v_54: G = __mc_out___mc_0[0];
         let __v_55: G = G::from_u64(0);
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_54, __v_5, __v_55]; 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 { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
         let __v_57: G = G::from_u64(1);
         let __v_58: G = (__v_49 + __v_57);
@@ -55494,30 +56151,30 @@ fn aiur_fn_656(
         let __v_62: G = (__v_60 - __v_61);
         let __v_63: G = G::from_u64(0);
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_65: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_66: G = G::from_u64(0);
-        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_65, __v_5, __v_66]; 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 { let __r = record.function_queries[650].replay_at(__i); record.virt += __r; } 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_67: G = __r_arr[0];
         let __v_68: G = G::from_u64(3);
         let __v_69: G = G::from_u64(0);
         let __v_70: G = G::from_u64(0);
         let __v_71: G = G::from_u64(0);
-        let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_73: G = G::from_u64(0);
-        let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_77: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_77, __v_43]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_78, __v_18]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_79, __v_17]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_80, __v_15]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
         let __ret: [G; OUT_656] = [__v_81];
-        if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[656].weight(); } record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -55537,6 +56194,7 @@ fn aiur_fn_657(
   unconstrained: bool,
 ) -> Result<[G; OUT_657], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55570,9 +56228,9 @@ fn aiur_fn_657(
             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_286] = { let __args: [G; IN_286] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20, __v_21, __v_26]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_29: G = __loaded[1];
     let __v_30: G = __loaded[2];
@@ -55595,9 +56253,9 @@ fn aiur_fn_657(
     let __v_29: G = G::from_u64(1);
     let __v_30: G = G::from_u64(0);
     let __v_31: G = G::from_u64(0);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_33: G = G::from_u64(0);
-    let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_35: G = G::from_u64(0);
     let __v_36: G = G::from_u64(0);
     break '__mc_0 [__v_26, __v_27, __v_28, __v_34, __v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36];
@@ -55620,85 +56278,85 @@ fn aiur_fn_657(
             let __v_39: G = (__v_16 + __v_17);
             let __v_40: G = G::from_u64(1);
             let __v_41: G = G::from_u64(1);
-            let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_15, __v_39, __v_42]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_20, __v_25]; 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 { let __r = record.function_queries[616].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
-            let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__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[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[610].replay_at(__i); record.virt += __r; } 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 __v_45: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() {
   1u64 => {
     let __v_46: G = G::from_u64(4);
     let __v_47: G = G::from_u64(0);
     let __v_48: G = G::from_u64(0);
-    let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_1 [__v_49];
   },
   _ => {
     let __v_46: G = G::from_u64(0);
     let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_1 [__v_48];
   },
 }
  };
             let __v_46: G = __mc_out___mc_1[0];
             let __v_47: G = G::from_u64(0);
-            let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_1, __v_47]; 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 { let __r = record.function_queries[690].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_10, __v_20, __v_45]; 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 { let __r = record.function_queries[633].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[664].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_49]; 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 { let __r = record.function_queries[667].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; 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 { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_20]; 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 { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
             let __v_54: G = G::from_u64(1);
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __v_56: G = (__v_54 - __v_55);
             let __v_57: G = (__v_53 * __v_56);
             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_630] = { let __args: [G; IN_630] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_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[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[630].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
     break '__mc_2 [__v_59];
   },
   _ => {
     let __v_59: G = G::from_u64(1);
     let __v_60: G = G::from_u64(1);
-    let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_2 [__v_61];
   },
 }
  };
             let __v_59: G = __mc_out___mc_2[0];
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_49, __v_25, __v_58, __v_59, __v_60]; 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 { let __r = record.function_queries[637].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
             let __v_62: G = __r_arr[1];
             match __v_61.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__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; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__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[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[658].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_657] = [];
-                if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_63: G = G::from_u64(0);
-                let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_25, __v_63]; 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 { let __r = record.function_queries[636].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
                 let __v_65: G = __r_arr[1];
                 match __v_64.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__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; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__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[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[658].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_657] = [];
-                    if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
@@ -55710,7 +56368,7 @@ fn aiur_fn_657(
           },
           _ => {
             let __ret: [G; OUT_657] = [];
-            if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[657].weight(); } record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -55732,6 +56390,7 @@ fn aiur_fn_658(
   unconstrained: bool,
 ) -> Result<[G; OUT_658], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55750,29 +56409,29 @@ fn aiur_fn_658(
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
-    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __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 { let __r = record.function_queries[638].replay_at(__i); record.virt += __r; } 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_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_655] = { let __args: [G; IN_655] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__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[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[655].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_10, __v_5, __v_23, __v_5]; 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 { let __r = record.function_queries[670].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_24]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_25: G = __r_arr[0];
     let __v_26: G = G::from_u64(0);
-    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_0, __v_1, __v_26]; 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 { let __r = record.function_queries[659].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
     let __v_28: G = G::from_u64(0);
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __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_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_2, __v_27, __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_28]; 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 { let __r = record.function_queries[660].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
     let __v_30: G = G::from_u64(1);
     let __v_31: G = G::from_u64(1);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_12, __v_22, __v_32]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
     let __v_34: G = G::from_u64(1);
     if (__v_33 != __v_34) {
@@ -55785,9 +56444,9 @@ fn aiur_fn_658(
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) });
     }
     let __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; 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 { let __r = record.function_queries[661].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_658] = [];
-    if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[658].weight(); } record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -55802,6 +56461,7 @@ fn aiur_fn_659(
   unconstrained: bool,
 ) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55810,11 +56470,11 @@ fn aiur_fn_659(
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_659] = [__v_4];
-        if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -55825,13 +56485,13 @@ fn aiur_fn_659(
           1u64 => {
             let __v_10: G = G::from_u64(0);
             let __ret: [G; OUT_659] = [__v_10];
-            if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_12: G = __loaded[1];
             let __v_13: G = __loaded[2];
@@ -55857,11 +56517,11 @@ fn aiur_fn_659(
             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_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_9, __v_1, __v_25]; 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 { let __r = record.function_queries[659].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
             let __v_27: G = (__v_23 + __v_26);
             let __ret: [G; OUT_659] = [__v_27];
-            if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[659].weight(); } record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -55883,6 +56543,7 @@ fn aiur_fn_660(
   unconstrained: bool,
 ) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55903,15 +56564,15 @@ fn aiur_fn_660(
       0u64 => {
         let __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_660] = [__v_18];
-        if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3, __v_14]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -55927,24 +56588,24 @@ fn aiur_fn_660(
         match __v_17.as_canonical_u64() {
           6u64 => {
             let __v_29: G = (__v_1 + __v_14);
-            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[663].replay_at(__i); record.virt += __r; } 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_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_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_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[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[660].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
-            let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_660] = [__v_35];
-            if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_29: G = G::from_u64(1);
             let __v_30: G = G::from_u64(1);
-            let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_660] = [__v_31];
-            if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[660].weight(); } record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -55963,6 +56624,7 @@ fn aiur_fn_661(
   unconstrained: bool,
 ) -> Result<[G; OUT_661], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -55972,7 +56634,7 @@ fn aiur_fn_661(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -55981,15 +56643,15 @@ fn aiur_fn_661(
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_661] = [];
-        if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_10.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5, __v_6, __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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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 __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
@@ -56022,14 +56684,14 @@ fn aiur_fn_661(
             if (__v_27 != __v_28) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) });
             }
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_29: G = __loaded[0];
             let __v_30: G = __loaded[1];
             let __v_31: G = __loaded[2];
             match __v_29.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_661] = [];
-                if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               0u64 => {
@@ -56039,8 +56701,8 @@ fn aiur_fn_661(
                 let __v_35: G = G::from_u64(0);
                 let __v_36: G = G::from_u64(1);
                 let __v_37: G = G::from_u64(1);
-                let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_12, __v_34, __v_35, __v_38]; 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 { let __r = record.function_queries[692].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
                 let __v_40: G = __r_arr[1];
                 let __v_41: G = __r_arr[2];
@@ -56049,8 +56711,8 @@ fn aiur_fn_661(
                 }
                 let __v_42: G = G::from_u64(1);
                 let __v_43: G = G::from_u64(1);
-                let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_39, __v_30, __v_44]; 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 { let __r = record.function_queries[435].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
                 let __v_46: G = G::from_u64(1);
                 if (__v_45 != __v_46) {
@@ -56058,9 +56720,9 @@ fn aiur_fn_661(
                 }
                 let __v_47: G = G::from_u64(1);
                 let __v_48: G = (__v_8 + __v_47);
-                let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__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[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[661].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_661] = [];
-                if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[661].weight(); } record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -56087,6 +56749,7 @@ fn aiur_fn_662(
   unconstrained: bool,
 ) -> Result<[G; OUT_662], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56099,19 +56762,19 @@ fn aiur_fn_662(
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_12: G = __loaded[0];
     let __v_13: G = __loaded[1];
     let __v_14: G = __loaded[2];
     match __v_12.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_662] = [__v_0];
-        if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[662].weight(); } record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_11, __v_15]; 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 { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
@@ -56145,62 +56808,62 @@ fn aiur_fn_662(
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
         let __v_48: G = G::from_u64(0);
-        let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_4, __v_16, __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 { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_5, __v_16, __v_51]; 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 { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } 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_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_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_13]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_56, __v_57, __v_58]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
         let __v_60: G = (__v_7 + __v_8);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_59, __v_60, __v_9]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_61]; 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 { let __r = record.function_queries[676].replay_at(__i); record.virt += __r; } 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_62: G = __r_arr[0];
         let __v_63: G = __r_arr[1];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_64: G = __r_arr[0];
         let __v_65: G = (__v_55 + __v_64);
         let __v_66: G = G::from_u64(2);
         let __v_67: G = G::from_u64(0);
-        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_69: G = G::from_u64(1);
         let __v_70: G = (__v_65 - __v_69);
         let __v_71: G = G::from_u64(0);
-        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_68, __v_6, __v_70, __v_71]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_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_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_72, __v_7, __v_75, __v_76]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_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_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_77, __v_8, __v_81, __v_82]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
         let __v_84: G = G::from_u64(1);
         let __v_85: G = G::from_u64(1);
-        let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_63, __v_86]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_87: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_87]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_88: G = __r_arr[0];
         let __v_89: G = __r_arr[1];
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_89, __v_52]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_90: G = __r_arr[0];
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_83, __v_90]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_91: G = __r_arr[0];
         let __v_92: G = G::from_u64(1);
         let __v_93: G = (__v_9 - __v_92);
@@ -56208,24 +56871,24 @@ fn aiur_fn_662(
         let __v_95: G = (__v_94 + __v_64);
         let __v_96: G = G::from_u64(0);
         let __v_97: G = G::from_u64(0);
-        let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_99: G = G::from_u64(0);
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_98, __v_64, __v_99]; 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 { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } 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_100: G = __r_arr[0];
         let __v_101: G = G::from_u64(3);
         let __v_102: G = G::from_u64(0);
-        let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_103, __v_62]; 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 { let __r = record.function_queries[654].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
         let __v_105: G = G::from_u64(3);
         let __v_106: G = G::from_u64(0);
-        let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_108: G = G::from_u64(1);
         let __v_109: G = (__v_11 + __v_108);
-        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__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[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[662].replay_at(__i); record.virt += __r; } 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_110: G = __r_arr[0];
         let __ret: [G; OUT_662] = [__v_110];
-        if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[662].weight(); } record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -56245,6 +56908,7 @@ fn aiur_fn_663(
   unconstrained: bool,
 ) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56258,32 +56922,32 @@ fn aiur_fn_663(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_6]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_13, __v_5]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
-    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14, __v_15]; 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 { let __r = record.function_queries[673].replay_at(__i); record.virt += __r; } 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_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_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; 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 { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
     let __v_23: G = G::from_u64(1);
     let __v_24: G = G::from_u64(1);
-    let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_26: G = G::from_u64(1);
     let __v_27: G = G::from_u64(1);
-    let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_29: G = G::from_u64(1);
     let __v_30: G = G::from_u64(1);
-    let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_32: G = G::from_u64(0);
     let __v_33: G = G::from_u64(0);
-    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; 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 { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
     let __v_35: G = __r_arr[1];
     let __v_36: G = __r_arr[2];
@@ -56295,15 +56959,15 @@ fn aiur_fn_663(
     let __v_42: G = (__v_39 - __v_41);
     let __v_43: G = G::from_u64(0);
     let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_46: G = G::from_u64(0);
-    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_45, __v_16, __v_16, __v_46]; 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 { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
     let __v_48: G = G::from_u64(0);
-    let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__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[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[662].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
     let __ret: [G; OUT_663] = [__v_49];
-    if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[663].weight(); } record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -56318,10 +56982,11 @@ fn aiur_fn_664(
   unconstrained: bool,
 ) -> Result<[G; OUT_664], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -56332,20 +56997,20 @@ fn aiur_fn_664(
       1u64 => {
         let __v_9: G = G::from_u64(1);
         let __v_10: G = G::from_u64(1);
-        let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_664] = [__v_11];
-        if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[664].weight(); } record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_1, __v_4, __v_6, __v_5, __v_2]; 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 { let __r = record.function_queries[665].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[664].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_664] = [__v_12];
-        if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[664].weight(); } record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -56365,12 +57030,13 @@ fn aiur_fn_665(
   unconstrained: bool,
 ) -> Result<[G; OUT_665], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = __r_arr[2];
@@ -56424,15 +57090,15 @@ fn aiur_fn_665(
         match __v_5.as_canonical_u64() {
           8u64 => {
             let __v_53: G = G::from_u64(0);
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; 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 { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
             let __ret: [G; OUT_665] = [__v_54];
-            if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[665].weight(); } record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_665] = [__v_4];
-            if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[665].weight(); } record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -56451,6 +57117,7 @@ fn aiur_fn_666(
   unconstrained: bool,
 ) -> Result<[G; OUT_666], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56459,7 +57126,7 @@ fn aiur_fn_666(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_8: G = __loaded[0];
     let __v_9: G = __loaded[1];
     let __v_10: G = __loaded[2];
@@ -56510,17 +57177,17 @@ fn aiur_fn_666(
     match __v_8.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_666] = [__v_6];
-        if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_2, __v_7]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_55]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
-            let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_58: G = __loaded[1];
             let __v_59: G = __loaded[2];
@@ -56535,11 +57202,11 @@ fn aiur_fn_666(
             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_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_59, __v_60, __v_62, __v_63, __v_61]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_69]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_72: G = __loaded[1];
     let __v_73: G = __loaded[2];
@@ -56563,7 +57230,7 @@ fn aiur_fn_666(
 }
  };
     let __v_83: G = __mc_out___mc_1[0];
-    let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_69, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_84: G = __r_arr[0];
     match __v_84.as_canonical_u64() {
       1u64 => {
@@ -56573,9 +57240,9 @@ fn aiur_fn_666(
             break '__mc_0 [__v_85];
           },
           _ => {
-            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; 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 { let __r = record.function_queries[621].replay_at(__i); record.virt += __r; } 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_85: G = __r_arr[0];
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_85, __v_4]; 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 { let __r = record.function_queries[629].replay_at(__i); record.virt += __r; } 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 __v_86: G = __r_arr[0];
             break '__mc_0 [__v_86];
           },
@@ -56597,16 +57264,16 @@ fn aiur_fn_666(
             match __v_69.as_canonical_u64() {
               1u64 => {
                 let __ret: [G; OUT_666] = [__v_55];
-                if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_70: G = G::from_u64(1);
                 let __v_71: G = (__v_7 + __v_70);
-                let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; 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 { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
                 let __ret: [G; OUT_666] = [__v_72];
-                if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -56614,10 +57281,10 @@ fn aiur_fn_666(
           _ => {
             let __v_55: G = G::from_u64(1);
             let __v_56: G = (__v_7 + __v_55);
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; 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 { let __r = record.function_queries[666].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
             let __ret: [G; OUT_666] = [__v_57];
-            if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[666].weight(); } record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -56639,8 +57306,9 @@ fn aiur_fn_667(
   unconstrained: bool,
 ) -> Result<[G; OUT_667], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -56651,15 +57319,15 @@ fn aiur_fn_667(
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_667] = [__v_9];
-        if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[667].weight(); } record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_2]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
@@ -56684,11 +57352,11 @@ fn aiur_fn_667(
  };
         let __v_20: G = __mc_out___mc_0[0];
         let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_6]; 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 { let __r = record.function_queries[667].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_667] = [__v_23];
-        if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[667].weight(); } record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -56708,10 +57376,11 @@ fn aiur_fn_668(
   unconstrained: bool,
 ) -> Result<[G; OUT_668], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0]; 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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -56720,7 +57389,7 @@ fn aiur_fn_668(
     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_289] = { let __args: [G; IN_289] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__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 { let __r = record.function_queries[290].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -56733,22 +57402,22 @@ fn aiur_fn_668(
     let __v_20: G = G::from_u64(0);
     let __v_21: G = G::from_u64(1);
     let __v_22: G = G::from_u64(1);
-    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_24: G = G::from_u64(1);
     let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_27: G = G::from_u64(1);
     let __v_28: G = G::from_u64(1);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_30: G = G::from_u64(1);
     let __v_31: G = G::from_u64(1);
-    let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_71(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_71] = unsafe { *(result.output.as_ptr() as *const [G; OUT_71]) }; __ret } } else { aiur_fn_71(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__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[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_668] = [__v_34];
-    if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[668].weight(); } record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -56763,6 +57432,7 @@ fn aiur_fn_669(
   unconstrained: bool,
 ) -> Result<[G; OUT_669], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56783,15 +57453,15 @@ fn aiur_fn_669(
       0u64 => {
         let __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_669] = [__v_18];
-        if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[669].weight(); } record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_11, __v_14]; 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 { let __r = record.function_queries[287].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -56806,20 +57476,20 @@ fn aiur_fn_669(
         let __v_28: G = __loaded[11];
         match __v_17.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_14, __v_10]; 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 { let __r = record.function_queries[668].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__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[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[675].replay_at(__i); record.virt += __r; } 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_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_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_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[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[669].replay_at(__i); record.virt += __r; } 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 __v_36: G = __r_arr[0];
-            let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_669] = [__v_37];
-            if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[669].weight(); } record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -56841,6 +57511,7 @@ fn aiur_fn_670(
   unconstrained: bool,
 ) -> Result<[G; OUT_670], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56848,10 +57519,10 @@ fn aiur_fn_670(
     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_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __ret: [G; OUT_670] = [__v_7];
-    if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[670].weight(); } record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -56866,6 +57537,7 @@ fn aiur_fn_671(
   unconstrained: bool,
 ) -> Result<[G; OUT_671], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56874,7 +57546,7 @@ fn aiur_fn_671(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_8: G = __loaded[0];
     let __v_9: G = __loaded[1];
     let __v_10: G = __loaded[2];
@@ -56885,15 +57557,15 @@ fn aiur_fn_671(
       1u64 => {
         let __v_14: G = G::from_u64(1);
         let __v_15: G = G::from_u64(1);
-        let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_671] = [__v_16];
-        if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_16: G = __loaded[1];
         let __v_17: G = __loaded[2];
@@ -56909,28 +57581,28 @@ fn aiur_fn_671(
         match __v_15.as_canonical_u64() {
           5u64 => {
             let __v_27: G = G::from_u64(0);
-            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__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[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[669].replay_at(__i); record.virt += __r; } 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 __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_28]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; 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 { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_28, __v_33]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_34: G = __r_arr[0];
             let __ret: [G; OUT_671] = [__v_34];
-            if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_7 + __v_27);
-            let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; 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 { let __r = record.function_queries[671].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
             let __ret: [G; OUT_671] = [__v_29];
-            if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[671].weight(); } record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -56952,6 +57624,7 @@ fn aiur_fn_672(
   unconstrained: bool,
 ) -> Result<[G; OUT_672], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -56964,24 +57637,24 @@ fn aiur_fn_672(
         let __v_7: G = (__v_1 - __v_6);
         let __v_8: G = (__v_7 - __v_0);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_672] = [__v_10];
-        if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_4]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_0]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_7, __v_2, __v_8]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
             let __ret: [G; OUT_672] = [__v_9];
-            if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -56990,9 +57663,9 @@ fn aiur_fn_672(
             let __v_9: G = (__v_1 - __v_8);
             let __v_10: G = (__v_9 - __v_0);
             let __v_11: G = G::from_u64(0);
-            let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_672] = [__v_12];
-            if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[672].weight(); } record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -57011,9 +57684,10 @@ fn aiur_fn_673(
   unconstrained: bool,
 ) -> Result<[G; OUT_673], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -57022,15 +57696,15 @@ fn aiur_fn_673(
       5u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_4, __v_7]; 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 { let __r = record.function_queries[673].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
         let __ret: [G; OUT_673] = [__v_8];
-        if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[673].weight(); } record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_673] = [__v_1];
-        if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[673].weight(); } record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -57047,6 +57721,7 @@ fn aiur_fn_674(
   unconstrained: bool,
 ) -> Result<[G; OUT_674], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57057,58 +57732,58 @@ fn aiur_fn_674(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_674] = [__v_0];
-        if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_8: G = __loaded[1];
         let __v_9: G = __loaded[2];
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[672].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_9, __v_11, __v_12]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; 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 { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __ret: [G; OUT_674] = [__v_18];
-            if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
-            let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __v_13: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_13]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
             let __v_16: G = __loaded[1];
             let __v_17: G = __loaded[2];
             let __v_18: G = __loaded[3];
             match __v_15.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_6, __v_2, __v_3, __v_4, __v_5]; 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 { let __r = record.function_queries[672].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
                 let __v_20: G = G::from_u64(0);
-                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_17, __v_19, __v_20]; 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 { let __r = record.function_queries[364].replay_at(__i); record.virt += __r; } 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_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_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __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 { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
                 let __ret: [G; OUT_674] = [__v_26];
-                if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[674].weight(); } record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -57132,6 +57807,7 @@ fn aiur_fn_675(
   unconstrained: bool,
 ) -> Result<[G; OUT_675], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57145,42 +57821,42 @@ fn aiur_fn_675(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; 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 { let __r = record.function_queries[333].replay_at(__i); record.virt += __r; } 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_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_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; 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 { let __r = record.function_queries[674].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_22: G = G::from_u64(1);
     let __v_23: G = G::from_u64(1);
-    let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_25: G = G::from_u64(1);
     let __v_26: G = G::from_u64(1);
-    let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_28: G = G::from_u64(0);
-    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; 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 { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } 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_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_760] = { let __args: [G; IN_760] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_29]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_30]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_32]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_38, __v_2]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_39: G = __r_arr[0];
     let __v_40: G = G::from_u64(0);
-    let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_39, __v_34, __v_40]; 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 { let __r = record.function_queries[679].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
     let __v_42: G = G::from_u64(1);
     let __v_43: G = (__v_36 - __v_42);
@@ -57188,29 +57864,29 @@ fn aiur_fn_675(
     let __v_45: G = (__v_43 - __v_44);
     let __v_46: G = G::from_u64(0);
     let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_48, __v_41]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; 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 { let __r = record.function_queries[681].replay_at(__i); record.virt += __r; } 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 __v_53: G = __r_arr[0];
     let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_53, __v_33, __v_35, __v_54]; 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 { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
     let __v_56: G = G::from_u64(3);
     let __v_57: G = G::from_u64(0);
-    let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_59: G = G::from_u64(0);
-    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; 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 { let __r = record.function_queries[678].replay_at(__i); record.virt += __r; } 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 __v_60: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_58, __v_60]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
-    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_61, __v_29]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_62: G = __r_arr[0];
     let __ret: [G; OUT_675] = [__v_62];
-    if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[675].weight(); } record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -57225,17 +57901,18 @@ fn aiur_fn_676(
   unconstrained: bool,
 ) -> Result<[G; OUT_676], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_3]; 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 { let __r = record.function_queries[677].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; 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 { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
     let __ret: [G; OUT_676] = [__v_6, __v_5];
-    if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[676].weight(); } record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -57250,9 +57927,10 @@ fn aiur_fn_677(
   unconstrained: bool,
 ) -> Result<[G; OUT_677], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -57260,17 +57938,17 @@ fn aiur_fn_677(
     match __v_2.as_canonical_u64() {
       5u64 => {
         let __v_6: G = G::from_u64(0);
-        let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; 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 { let __r = record.function_queries[677].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __ret: [G; OUT_677] = [__v_8, __v_9];
-        if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[677].weight(); } record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __ret: [G; OUT_677] = [__v_1, __v_0];
-        if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[677].weight(); } record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -57287,6 +57965,7 @@ fn aiur_fn_678(
   unconstrained: bool,
 ) -> Result<[G; OUT_678], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57295,7 +57974,7 @@ fn aiur_fn_678(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_8: G = __loaded[0];
     let __v_9: G = __loaded[1];
     let __v_10: G = __loaded[2];
@@ -57303,31 +57982,31 @@ fn aiur_fn_678(
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_678] = [__v_13];
-        if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[678].weight(); } record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_7, __v_11]; 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 { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(0);
-        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_3, __v_12, __v_13]; 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 { let __r = record.function_queries[752].replay_at(__i); record.virt += __r; } 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_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_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_9]; 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 { let __r = record.function_queries[762].replay_at(__i); record.virt += __r; } 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 __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_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_17, __v_19, __v_20]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_21]; 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 { let __r = record.function_queries[676].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_22]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __v_24: G = __r_arr[0];
         let __v_25: G = (__v_16 + __v_24);
         let __v_26: G = G::from_u64(1);
@@ -57340,38 +58019,38 @@ fn aiur_fn_678(
         let __v_33: G = (__v_31 - __v_32);
         let __v_34: G = G::from_u64(1);
         let __v_35: G = G::from_u64(1);
-        let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_23, __v_36]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_37]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_39, __v_14]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_43, __v_40]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_47: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_48: G = G::from_u64(0);
-        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_47, __v_24, __v_48]; 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 { let __r = record.function_queries[645].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(3);
         let __v_51: G = G::from_u64(0);
-        let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_52, __v_22]; 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 { let __r = record.function_queries[646].replay_at(__i); record.virt += __r; } 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_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_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; 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 { let __r = record.function_queries[678].replay_at(__i); record.virt += __r; } 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 __v_57: G = __r_arr[0];
-        let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_678] = [__v_58];
-        if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[678].weight(); } record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -57391,10 +58070,11 @@ fn aiur_fn_679(
   unconstrained: bool,
 ) -> Result<[G; OUT_679], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -57402,20 +58082,20 @@ fn aiur_fn_679(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_679] = [__v_8];
-        if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[679].weight(); } record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1, __v_2]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_5, __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 { let __r = record.function_queries[679].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-        let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_679] = [__v_9];
-        if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[679].weight(); } record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -57435,6 +58115,7 @@ fn aiur_fn_680(
   unconstrained: bool,
 ) -> Result<[G; OUT_680], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57443,7 +58124,7 @@ fn aiur_fn_680(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_680] = [__v_0];
-        if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[680].weight(); } record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -57452,16 +58133,16 @@ fn aiur_fn_680(
         let __v_7: G = (__v_2 - __v_6);
         let __v_8: G = (__v_7 - __v_3);
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_11: G = G::from_u64(3);
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_14: G = G::from_u64(1);
         let __v_15: G = (__v_3 + __v_14);
-        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_13, __v_1, __v_2, __v_15]; 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 { let __r = record.function_queries[680].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
         let __ret: [G; OUT_680] = [__v_16];
-        if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[680].weight(); } record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -57478,6 +58159,7 @@ fn aiur_fn_681(
   unconstrained: bool,
 ) -> Result<[G; OUT_681], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57489,18 +58171,18 @@ fn aiur_fn_681(
         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_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_2, __v_7, __v_8]; 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 { let __r = record.function_queries[653].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
         let __ret: [G; OUT_681] = [__v_9];
-        if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[681].weight(); } record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_5, __v_6]; 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 { let __r = record.function_queries[643].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_681] = [__v_7];
-        if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[681].weight(); } record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -57517,14 +58199,15 @@ fn aiur_fn_682(
   unconstrained: bool,
 ) -> Result<[G; OUT_682], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[683].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __ret: [G; OUT_682] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[682].weight(); } record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -57539,33 +58222,34 @@ fn aiur_fn_683(
   unconstrained: bool,
 ) -> Result<[G; OUT_683], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = G::from_u64(1);
-    let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_5]; 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 { let __r = record.function_queries[414].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_9, __v_1, __v_2]; 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 { let __r = record.function_queries[683].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __ret: [G; OUT_683] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_6]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
         let __v_14: G = __loaded[1];
         let __v_15: G = __loaded[2];
@@ -57573,18 +58257,18 @@ fn aiur_fn_683(
         match __v_13.as_canonical_u64() {
           2u64 => {
             let __v_17: G = G::from_u64(0);
-            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_1, __v_14, __v_12, __v_2, __v_17]; 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 { let __r = record.function_queries[684].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
             let __ret: [G; OUT_683] = [__v_18, __v_19];
-            if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
             let __ret: [G; OUT_683] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[683].weight(); } record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -57603,12 +58287,13 @@ fn aiur_fn_684(
   unconstrained: bool,
 ) -> Result<[G; OUT_684], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -57620,11 +58305,11 @@ fn aiur_fn_684(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
         let __ret: [G; OUT_684] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   0u64 => {
@@ -57632,7 +58317,7 @@ fn aiur_fn_684(
     break '__mc_0 [__v_12];
   },
   _ => {
-    let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_2, __v_3]; 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 { let __r = record.function_queries[685].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
     break '__mc_0 [__v_12];
   },
@@ -57644,17 +58329,17 @@ fn aiur_fn_684(
           1u64 => {
             let __v_14: G = G::from_u64(1);
             let __ret: [G; OUT_684] = [__v_14, __v_4];
-            if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_4 + __v_14);
-            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_10, __v_1, __v_2, __v_3, __v_15]; 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 { let __r = record.function_queries[684].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
             let __ret: [G; OUT_684] = [__v_16, __v_17];
-            if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[684].weight(); } record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -57676,10 +58361,11 @@ fn aiur_fn_685(
   unconstrained: bool,
 ) -> Result<[G; OUT_685], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -57687,11 +58373,11 @@ fn aiur_fn_685(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __ret: [G; OUT_685] = [__v_6];
-        if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -57699,27 +58385,27 @@ fn aiur_fn_685(
           1u64 => {
             let __v_9: G = G::from_u64(0);
             let __ret: [G; OUT_685] = [__v_9];
-            if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_2, __v_9]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10, __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 { let __r = record.function_queries[627].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_5, __v_8, __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 { let __r = record.function_queries[685].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
                 let __ret: [G; OUT_685] = [__v_12];
-                if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __ret: [G; OUT_685] = [__v_12];
-                if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[685].weight(); } record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -57746,6 +58432,7 @@ fn aiur_fn_686(
   unconstrained: bool,
 ) -> Result<[G; OUT_686], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57753,7 +58440,7 @@ fn aiur_fn_686(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
@@ -57761,51 +58448,51 @@ fn aiur_fn_686(
     match __v_7.as_canonical_u64() {
       5u64 => {
         let __v_11: G = (__v_6 + __v_5);
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_8, __v_1, __v_11]; 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 { let __r = record.function_queries[682].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_16: G = G::from_u64(0);
-            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_18: G = G::from_u64(0);
-            let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __v_20: G = G::from_u64(1);
             let __v_21: G = (__v_5 + __v_20);
-            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __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 { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } 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_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_686] = [__v_22, __v_23, __v_24, __v_25];
-            if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_5 + __v_16);
-            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __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 { let __r = record.function_queries[686].replay_at(__i); record.virt += __r; } 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_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_686] = [__v_18, __v_19, __v_20, __v_21];
-            if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_2]; 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 { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_3]; 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 { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_4]; 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 { let __r = record.function_queries[758].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
         let __ret: [G; OUT_686] = [__v_11, __v_12, __v_13, __v_0];
-        if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[686].weight(); } record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -57822,11 +58509,12 @@ fn aiur_fn_687(
   unconstrained: bool,
 ) -> Result<[G; OUT_687], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -57837,15 +58525,15 @@ fn aiur_fn_687(
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_687] = [__v_12];
-        if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_5]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_12: G = __loaded[1];
         let __v_13: G = __loaded[2];
@@ -57860,26 +58548,26 @@ fn aiur_fn_687(
         let __v_22: G = __loaded[11];
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__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[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[651].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
             let __v_24: G = G::from_u64(0);
-            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_23, __v_3, __v_24]; 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 { let __r = record.function_queries[355].replay_at(__i); record.virt += __r; } 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_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_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_28]; 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 { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
-            let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_687] = [__v_30];
-            if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2, __v_3]; 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 { let __r = record.function_queries[687].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
             let __ret: [G; OUT_687] = [__v_23];
-            if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[687].weight(); } record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -57901,6 +58589,7 @@ fn aiur_fn_688(
   unconstrained: bool,
 ) -> Result<[G; OUT_688], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -57916,11 +58605,11 @@ fn aiur_fn_688(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_3, __v_5, __v_6, __v_4]; 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 { let __r = record.function_queries[619].replay_at(__i); record.virt += __r; } 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 __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_13]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_16: G = __loaded[1];
         let __v_17: G = __loaded[2];
@@ -57935,12 +58624,12 @@ fn aiur_fn_688(
         let __v_26: G = __loaded[11];
         match __v_15.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_10]; 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 { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22]; 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 { let __r = record.function_queries[617].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
             let __v_29: G = G::from_u64(1);
-            let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+            let __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
             let __v_31: G = (__v_29 - __v_30);
             let __v_32: G = (__v_28 * __v_31);
@@ -57950,11 +58639,11 @@ fn aiur_fn_688(
             let __v_36: G = (__v_34 + __v_35);
             let __v_37: G = G::from_u64(1);
             let __v_38: G = (__v_36 + __v_37);
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_38]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
             let __v_40: G = (__v_5 + __v_6);
             let __v_41: G = (__v_3 + __v_40);
-            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_41, __v_1]; 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 { let __r = record.function_queries[691].replay_at(__i); record.virt += __r; } 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 __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() {
   1u64 => {
     break '__mc_0 [];
@@ -57967,15 +58656,15 @@ fn aiur_fn_688(
       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_42: G = (__v_18 + __v_19);
-    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; 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 { let __r = record.function_queries[689].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
 }
  };
-            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_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[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[615].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
-            let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[607].replay_at(__i); record.virt += __r; } 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_772] = { let __args: [G; IN_772] = [__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 { let __r = record.function_queries[772].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
             if (__v_43 != __v_20) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) });
@@ -57983,9 +58672,9 @@ fn aiur_fn_688(
             if (__v_8 != __v_42) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) });
             }
-            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_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; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_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[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[657].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_688] = [];
-            if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[688].weight(); } record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -58010,6 +58699,7 @@ fn aiur_fn_689(
   unconstrained: bool,
 ) -> Result<[G; OUT_689], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -58019,25 +58709,25 @@ fn aiur_fn_689(
     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_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_8]; 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 { let __r = record.function_queries[582].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_11: G = __loaded[1];
     let __v_12: G = __loaded[2];
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_15]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_689] = [];
-        if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[689].weight(); } record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -58057,6 +58747,7 @@ fn aiur_fn_690(
   unconstrained: bool,
 ) -> Result<[G; OUT_690], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = (__v_0 - __v_1);
@@ -58064,23 +58755,23 @@ fn aiur_fn_690(
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_690] = [__v_5];
-        if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[690].weight(); } record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_3: G = G::from_u64(0);
         let __v_4: G = G::from_u64(4);
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_8]; 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 { let __r = record.function_queries[690].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_690] = [__v_10];
-        if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[690].weight(); } record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -58097,10 +58788,11 @@ fn aiur_fn_691(
   unconstrained: bool,
 ) -> Result<[G; OUT_691], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -58109,17 +58801,17 @@ fn aiur_fn_691(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_691] = [];
-        if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[691].weight(); } record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_4.as_canonical_u64() {
           _ => {
             let __v_8: G = (__v_1 + __v_5);
-            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_6, __v_8, __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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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_691] = { let __args: [G; IN_691] = [__v_7, __v_1, __v_2]; 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 { let __r = record.function_queries[691].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_691] = [];
-            if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[691].weight(); } record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -58141,6 +58833,7 @@ fn aiur_fn_692(
   unconstrained: bool,
 ) -> Result<[G; OUT_692], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -58148,11 +58841,11 @@ fn aiur_fn_692(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3];
-        if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -58164,18 +58857,18 @@ fn aiur_fn_692(
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_2 + __v_10);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_9, __v_11, __v_13]; 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 { let __r = record.function_queries[692].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
             let __ret: [G; OUT_692] = [__v_14, __v_15, __v_16];
-            if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_692] = [__v_0, __v_2, __v_3];
-            if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[692].weight(); } record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -58194,6 +58887,7 @@ fn aiur_fn_693(
   unconstrained: bool,
 ) -> Result<[G; OUT_693], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -58207,58 +58901,58 @@ fn aiur_fn_693(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__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[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[572].replay_at(__i); record.virt += __r; } 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_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_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; 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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_20: G = G::from_u64(1);
         let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; 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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; 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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_20: G = G::from_u64(0);
         let __v_21: G = G::from_u64(0);
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_19, __v_22]; 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 { let __r = record.function_queries[321].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
         let __v_24: G = G::from_u64(1);
         if (__v_23 != __v_24) {
@@ -58266,74 +58960,74 @@ fn aiur_fn_693(
         }
         let __v_25: G = G::from_u64(1);
         let __v_26: G = G::from_u64(1);
-        let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_27]; 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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3, __v_15, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_16: G = G::from_u64(1);
         let __v_17: G = G::from_u64(1);
-        let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_18]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_574] = { let __args: [G; IN_574] = [__v_13, __v_3]; 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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_20: G = G::from_u64(1);
         let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_3, __v_2, __v_22]; 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 { let __r = record.function_queries[496].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_581] = { let __args: [G; IN_581] = [__v_12, __v_3, __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 { let __r = record.function_queries[581].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_571] = { let __args: [G; IN_571] = [__v_7]; 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 { let __r = record.function_queries[571].replay_at(__i); record.virt += __r; } 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_605] = { let __args: [G; IN_605] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __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 { let __r = record.function_queries[605].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __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[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[608].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_286] = { let __args: [G; IN_286] = [__v_3, __v_4]; 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 { let __r = record.function_queries[286].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+        let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_21: G = __loaded[1];
         let __v_22: G = __loaded[2];
@@ -58348,15 +59042,15 @@ fn aiur_fn_693(
         let __v_31: G = __loaded[11];
         match __v_20.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_22, __v_2, __v_23]; 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 { let __r = record.function_queries[588].replay_at(__i); record.virt += __r; } 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_586] = { let __args: [G; IN_586] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; 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 { let __r = record.function_queries[586].replay_at(__i); record.virt += __r; } 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_32: G = (__v_23 + __v_24);
             let __v_33: G = G::from_u64(1);
             let __v_34: G = G::from_u64(1);
-            let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } };
+            let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_22, __v_32, __v_35]; 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 { let __r = record.function_queries[589].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6, __v_36]; 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 { let __r = record.function_queries[592].replay_at(__i); record.virt += __r; } 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)? } };
             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()) });
             }
@@ -58364,15 +59058,15 @@ fn aiur_fn_693(
               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(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } };
+                let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6, __v_3, __v_39]; 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 { let __r = record.function_queries[604].replay_at(__i); record.virt += __r; } 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_693] = [];
-                if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __ret: [G; OUT_693] = [];
-                if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58384,17 +59078,17 @@ fn aiur_fn_693(
       },
       7u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_14, __v_1]; 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 { let __r = record.function_queries[577].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(1);
         let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_2, __v_17]; 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 { let __r = record.function_queries[495].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_13, __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 { let __r = record.function_queries[574].replay_at(__i); record.virt += __r; } 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_571] = { let __args: [G; IN_571] = [__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 { let __r = record.function_queries[571].replay_at(__i); record.virt += __r; } 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_688] = { let __args: [G; IN_688] = [__v_0, __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[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[688].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_693] = [];
-        if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[693].weight(); } record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -58414,10 +59108,11 @@ fn aiur_fn_694(
   unconstrained: bool,
 ) -> Result<[G; OUT_694], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -58430,9 +59125,9 @@ fn aiur_fn_694(
     let __v_11: G = __loaded[9];
     let __v_12: G = __loaded[10];
     let __v_13: G = __loaded[11];
-    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_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; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_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[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[693].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_694] = [];
-    if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[694].weight(); } record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -58447,8 +59142,9 @@ fn aiur_fn_695(
   unconstrained: bool,
 ) -> Result<[G; OUT_695], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -58470,81 +59166,81 @@ fn aiur_fn_695(
     match __v_1.as_canonical_u64() {
       2u64 => {
         let __v_19: G = G::from_u64(0);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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 __v_21: G = G::from_u64(1);
         let __v_22: G = G::from_u64(1);
-        let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_695] = [__v_24];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
         let __v_19: G = G::from_u64(0);
-        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; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[17].replay_at(__i); record.virt += __r; } 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_695] = { let __args: [G; IN_695] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_18]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_695] = [__v_22];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
         let __ret: [G; OUT_695] = [__v_21];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
         let __ret: [G; OUT_695] = [__v_21];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_3]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_20]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
         let __ret: [G; OUT_695] = [__v_21];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_19, __v_22]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_23: G = __r_arr[0];
         let __ret: [G; OUT_695] = [__v_23];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_19: G = G::from_u64(1);
         let __v_20: G = G::from_u64(1);
-        let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_695] = [__v_21];
-        if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[695].weight(); } record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -58561,8 +59257,9 @@ fn aiur_fn_696(
   unconstrained: bool,
 ) -> Result<[G; OUT_696], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -58570,20 +59267,20 @@ fn aiur_fn_696(
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_696] = [__v_6];
-        if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[696].weight(); } record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_2]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3]; 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 { let __r = record.function_queries[696].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_5]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
         let __ret: [G; OUT_696] = [__v_6];
-        if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[696].weight(); } record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -58603,8 +59300,9 @@ fn aiur_fn_697(
   unconstrained: bool,
 ) -> Result<[G; OUT_697], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -58620,22 +59318,22 @@ fn aiur_fn_697(
       1u64 => {
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_697] = [__v_14];
-        if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[697].weight(); } record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_2.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__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 { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_13]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
             let __ret: [G; OUT_697] = [__v_14];
-            if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[697].weight(); } record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -58657,8 +59355,9 @@ fn aiur_fn_698(
   unconstrained: bool,
 ) -> Result<[G; OUT_698], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -58699,22 +59398,22 @@ fn aiur_fn_698(
       1u64 => {
         let __v_37: G = G::from_u64(1);
         let __v_38: G = G::from_u64(1);
-        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_698] = [__v_39];
-        if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[698].weight(); } record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         match __v_2.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_35]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_36]; 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 { let __r = record.function_queries[698].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_37, __v_38]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_39: G = __r_arr[0];
             let __ret: [G; OUT_698] = [__v_39];
-            if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[698].weight(); } record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -58736,8 +59435,9 @@ fn aiur_fn_699(
   unconstrained: bool,
 ) -> Result<[G; OUT_699], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -58789,9 +59489,9 @@ fn aiur_fn_699(
       1u64 => {
         let __v_48: G = G::from_u64(1);
         let __v_49: G = G::from_u64(1);
-        let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_699] = [__v_50];
-        if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -58799,18 +59499,18 @@ fn aiur_fn_699(
           0u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; 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 { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_699] = [__v_52];
-                if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58818,18 +59518,18 @@ fn aiur_fn_699(
           1u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_28]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_29]; 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 { let __r = record.function_queries[698].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; 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 { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_699] = [__v_52];
-                if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58837,18 +59537,18 @@ fn aiur_fn_699(
           2u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_45]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_46]; 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 { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_47]; 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 { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_50, __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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_699] = [__v_52];
-                if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[699].weight(); } record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58875,6 +59575,7 @@ fn aiur_fn_700(
   unconstrained: bool,
 ) -> Result<[G; OUT_700], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -58925,22 +59626,22 @@ fn aiur_fn_700(
     let __v_47: G = inp[47];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_45]; 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 { let __r = record.function_queries[696].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_700] = [__v_52];
-                if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58948,16 +59649,16 @@ fn aiur_fn_700(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_43]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_44]; 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 { let __r = record.function_queries[697].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_49, __v_50]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_52: G = __r_arr[0];
                 let __ret: [G; OUT_700] = [__v_52];
-                if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58965,12 +59666,12 @@ fn aiur_fn_700(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
                 let __ret: [G; OUT_700] = [__v_50];
-                if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -58978,28 +59679,28 @@ fn aiur_fn_700(
           3u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_10]; 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 { let __r = record.function_queries[695].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
                 let __ret: [G; OUT_700] = [__v_50];
-                if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           8u64 => {
-            let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1]; 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 { let __r = record.function_queries[699].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_48, __v_49]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
             let __ret: [G; OUT_700] = [__v_50];
-            if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __ret: [G; OUT_700] = [__v_48];
-            if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[700].weight(); } record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -59018,9 +59719,10 @@ fn aiur_fn_701(
   unconstrained: bool,
 ) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -59028,7 +59730,7 @@ fn aiur_fn_701(
       1u64 => {
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_701] = [__v_5];
-        if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -59037,14 +59739,14 @@ fn aiur_fn_701(
           0u64 => {
             let __v_6: G = G::from_u64(1);
             let __ret: [G; OUT_701] = [__v_6];
-            if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_4, __v_1]; 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 { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __ret: [G; OUT_701] = [__v_6];
-            if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[701].weight(); } record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -59066,8 +59768,9 @@ fn aiur_fn_702(
   unconstrained: bool,
 ) -> Result<[G; OUT_702], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -59121,14 +59824,14 @@ fn aiur_fn_702(
         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_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_2, __v_2, __v_49]; 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 { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
   7u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_702] = { let __args: [G; IN_702] = [__v_10]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_0 [];
       },
     }
@@ -59136,8 +59839,8 @@ fn aiur_fn_702(
   6u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_702] = { let __args: [G; IN_702] = [__v_10]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_0 [];
       },
     }
@@ -59145,8 +59848,8 @@ fn aiur_fn_702(
   4u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_702] = { let __args: [G; IN_702] = [__v_18]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_0 [];
       },
     }
@@ -59154,24 +59857,24 @@ fn aiur_fn_702(
   5u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_702] = { let __args: [G; IN_702] = [__v_10]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_0 [];
       },
     }
   },
   _ => {
-    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
 }
  };
-        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[700].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
         let __v_50: G = G::from_u64(0);
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47, __v_49, __v_50]; 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 { let __r = record.function_queries[703].replay_at(__i); record.virt += __r; } 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_702] = [];
-        if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[702].weight(); } record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -59188,25 +59891,26 @@ fn aiur_fn_703(
   unconstrained: bool,
 ) -> Result<[G; OUT_703], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_703] = [];
-        if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[703].weight(); } record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; 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 { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } 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_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_702] = { let __args: [G; IN_702] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_4]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -59216,9 +59920,9 @@ fn aiur_fn_703(
  };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_5, __v_1, __v_8]; 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 { let __r = record.function_queries[703].replay_at(__i); record.virt += __r; } 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_703] = [];
-        if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[703].weight(); } record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -59238,11 +59942,12 @@ fn aiur_fn_704(
   unconstrained: bool,
 ) -> Result<[G; OUT_704], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
@@ -59293,16 +59998,16 @@ fn aiur_fn_704(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_704] = [];
-        if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[704].weight(); } record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__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[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[705].replay_at(__i); record.virt += __r; } 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_51: G = G::from_u64(1);
         let __v_52: G = (__v_3 + __v_51);
-        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_1, __v_50, __v_52]; 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 { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_704] = [];
-        if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[704].weight(); } record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -59322,6 +60027,7 @@ fn aiur_fn_705(
   unconstrained: bool,
 ) -> Result<[G; OUT_705], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -59370,11 +60076,11 @@ fn aiur_fn_705(
     let __v_45: G = inp[45];
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_1, __v_0, __v_47]; 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 { let __r = record.function_queries[291].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_48]; 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 { let __r = record.function_queries[284].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
-    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
+    let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_51: G = __loaded[1];
     let __v_52: G = __loaded[2];
@@ -59387,9 +60093,9 @@ fn aiur_fn_705(
     let __v_59: G = __loaded[9];
     let __v_60: G = __loaded[10];
     let __v_61: G = __loaded[11];
-    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__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; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__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[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[693].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_705] = [];
-    if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[705].weight(); } record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -59404,19 +60110,20 @@ fn aiur_fn_706(
   unconstrained: bool,
 ) -> Result<[G; OUT_706], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+    let __v_3: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_3]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
-    let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __v_7: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_706] = [__v_8];
-    if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[706].weight(); } record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -59431,22 +60138,23 @@ fn aiur_fn_707(
   unconstrained: bool,
 ) -> Result<[G; OUT_707], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_1, __v_4]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_45(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_45] = unsafe { *(result.output.as_ptr() as *const [G; OUT_45]) }; __ret } } else { aiur_fn_45(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_5]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(1);
-    let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_707] = [__v_10];
-    if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[707].weight(); } record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -59461,24 +60169,25 @@ fn aiur_fn_708(
   unconstrained: bool,
 ) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
-        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; 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 { let __r = record.function_queries[706].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_708] = [__v_5, __v_10, __v_4];
-        if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
@@ -59514,29 +60223,29 @@ fn aiur_fn_708(
         let __v_32: G = G::from_u64(0);
         let __v_33: G = G::from_u64(0);
         let __v_34: G = G::from_u64(0);
-        let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_36: G = G::from_u64(1);
         let __v_37: G = G::from_u64(1);
-        let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_708] = [__v_35, __v_38, __v_2];
-        if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2]; 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 { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } 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 __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_708] = { let __args: [G; IN_708] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_5]; 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 { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } 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 __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_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_3, __v_6]; 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 { let __r = record.function_queries[707].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_7]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
         let __ret: [G; OUT_708] = [__v_9, __v_10, __v_8];
-        if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[708].weight(); } record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -59556,8 +60265,9 @@ fn aiur_fn_709(
   unconstrained: bool,
 ) -> Result<[G; OUT_709], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -59595,9 +60305,9 @@ fn aiur_fn_709(
     let __v_34: G = __io_pair.0;
     let __v_35: G = __io_pair.1;
     let __v_36: G = G::from_u64(1);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __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_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
     let __v_40: G = __r_arr[2];
@@ -59608,11 +60318,11 @@ fn aiur_fn_709(
     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_708] = { let __args: [G; IN_708] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_47]; 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 { let __r = record.function_queries[708].replay_at(__i); record.virt += __r; } 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 __v_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
     let __v_50: G = __r_arr[2];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_51: G = __loaded[0];
     let __v_52: G = __loaded[1];
     let __v_53: G = __loaded[2];
@@ -59653,7 +60363,7 @@ fn aiur_fn_709(
     if (__v_39 != __v_84) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) });
     }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_85: G = __loaded[0];
     let __v_86: G = __loaded[1];
     let __v_87: G = __loaded[2];
@@ -59765,7 +60475,7 @@ fn aiur_fn_709(
       return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
     }
     let __ret: [G; OUT_709] = [__v_49];
-    if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[709].weight(); } record.function_queries[709].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -59780,6 +60490,7 @@ fn aiur_fn_710(
   unconstrained: bool,
 ) -> Result<[G; OUT_710], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -59787,26 +60498,26 @@ fn aiur_fn_710(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[710].weight(); } record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __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 { let __r = record.function_queries[773].replay_at(__i); record.virt += __r; } 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_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_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -59814,7 +60525,7 @@ fn aiur_fn_710(
         let __v_21: G = __r_arr[4];
         let __v_22: G = __r_arr[5];
         let __ret: [G; OUT_710] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[710].weight(); } record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -59834,6 +60545,7 @@ fn aiur_fn_711(
   unconstrained: bool,
 ) -> Result<[G; OUT_711], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -59842,10 +60554,10 @@ fn aiur_fn_711(
     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_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
     let __ret: [G; OUT_711] = [__v_8];
-    if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[711].weight(); } record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -59860,6 +60572,7 @@ fn aiur_fn_712(
   unconstrained: bool,
 ) -> Result<[G; OUT_712], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -59874,18 +60587,18 @@ fn aiur_fn_712(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[711].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
     match __v_14.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_712] = [];
-        if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[712].weight(); } record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[711].replay_at(__i); record.virt += __r; } 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 __v_15: G = __r_arr[0];
     let __v_16: G = G::from_u64(1);
     if (__v_15 != __v_16) {
@@ -59898,7 +60611,7 @@ fn aiur_fn_712(
   },
 }
  };
-        let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         let __v_17: G = __r_arr[2];
@@ -59952,14 +60665,14 @@ fn aiur_fn_712(
             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_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0, __v_16, __v_16, __v_63]; 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 { let __r = record.function_queries[704].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_1 [];
   },
   7u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_712] = { let __args: [G; IN_712] = [__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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_1 [];
       },
     }
@@ -59967,8 +60680,8 @@ fn aiur_fn_712(
   6u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_712] = { let __args: [G; IN_712] = [__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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_1 [];
       },
     }
@@ -59976,8 +60689,8 @@ fn aiur_fn_712(
   4u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_712] = { let __args: [G; IN_712] = [__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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_1 [];
       },
     }
@@ -59985,24 +60698,24 @@ fn aiur_fn_712(
   5u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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_712] = { let __args: [G; IN_712] = [__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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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)? } };
         break '__mc_1 [];
       },
     }
   },
   _ => {
-    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0]; 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 { let __r = record.function_queries[694].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_1 [];
   },
 }
  };
-            let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[700].replay_at(__i); record.virt += __r; } 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_63: G = __r_arr[0];
             let __v_64: G = G::from_u64(0);
-            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_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[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[713].replay_at(__i); record.virt += __r; } 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_712] = [];
-            if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[712].weight(); } record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -60021,6 +60734,7 @@ fn aiur_fn_713(
   unconstrained: bool,
 ) -> Result<[G; OUT_713], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -60037,22 +60751,22 @@ fn aiur_fn_713(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_16: G = __loaded[0];
     let __v_17: G = __loaded[1];
     let __v_18: G = __loaded[2];
     match __v_16.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_713] = [];
-        if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[713].weight(); } record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_1, __v_2]; 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 { let __r = record.function_queries[701].replay_at(__i); record.virt += __r; } 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_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_712] = { let __args: [G; IN_712] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -60062,9 +60776,9 @@ fn aiur_fn_713(
  };
         let __v_20: G = G::from_u64(1);
         let __v_21: G = (__v_2 + __v_20);
-        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_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[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[713].replay_at(__i); record.virt += __r; } 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_713] = [];
-        if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[713].weight(); } record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -60084,6 +60798,7 @@ fn aiur_fn_714(
   unconstrained: bool,
 ) -> Result<[G; OUT_714], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -60097,22 +60812,22 @@ fn aiur_fn_714(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_13: G = __loaded[0];
     let __v_14: G = __loaded[1];
     let __v_15: G = __loaded[2];
     match __v_13.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_714] = [];
-        if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[714].weight(); } record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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_714] = { let __args: [G; IN_714] = [__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[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[714].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_714] = [];
-        if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[714].weight(); } record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -60132,20 +60847,21 @@ fn aiur_fn_715(
   unconstrained: bool,
 ) -> Result<[G; OUT_715], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() {
   1u64 => {
     let __v_4: G = G::from_u64(1);
     let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_0 [__v_6];
   },
   0u64 => {
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2]; 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 { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
     break '__mc_0 [__v_4];
   },
@@ -60157,7 +60873,7 @@ fn aiur_fn_715(
     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_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; 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 { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
     let __v_9: G = __r_arr[2];
@@ -60166,16 +60882,16 @@ fn aiur_fn_715(
     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_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __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 { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } 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_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_714] = { let __args: [G; IN_714] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__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[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[714].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_715] = [];
-    if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[715].weight(); } record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -60190,8 +60906,9 @@ fn aiur_fn_716(
   unconstrained: bool,
 ) -> Result<[G; OUT_716], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
@@ -60199,16 +60916,16 @@ fn aiur_fn_716(
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_716] = [__v_3, __v_4, __v_2];
-        if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[716].weight(); } record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_2]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = G::from_u64(0);
         let __ret: [G; OUT_716] = [__v_5, __v_3, __v_4];
-        if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[716].weight(); } record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -60228,6 +60945,7 @@ fn aiur_fn_717(
   unconstrained: bool,
 ) -> Result<[G; OUT_717], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60235,11 +60953,11 @@ fn aiur_fn_717(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_717] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[717].weight(); } record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60251,7 +60969,7 @@ fn aiur_fn_717(
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(0);
         let __ret: [G; OUT_717] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[717].weight(); } record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60268,6 +60986,7 @@ fn aiur_fn_718(
   unconstrained: bool,
 ) -> Result<[G; OUT_718], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60275,16 +60994,16 @@ fn aiur_fn_718(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_718] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[718].weight(); } record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_1]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_718] = [__v_4, __v_2, __v_3];
-        if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[718].weight(); } record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60301,6 +61020,7 @@ fn aiur_fn_719(
   unconstrained: bool,
 ) -> Result<[G; OUT_719], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60308,16 +61028,16 @@ fn aiur_fn_719(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_719] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[719].weight(); } record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_719] = [__v_4, __v_2, __v_3];
-        if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[719].weight(); } record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60334,6 +61054,7 @@ fn aiur_fn_720(
   unconstrained: bool,
 ) -> Result<[G; OUT_720], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60341,11 +61062,11 @@ fn aiur_fn_720(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_720] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -60353,21 +61074,21 @@ fn aiur_fn_720(
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(0);
             let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(1);
             let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(2);
             let __ret: [G; OUT_720] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[720].weight(); } record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -60389,6 +61110,7 @@ fn aiur_fn_721(
   unconstrained: bool,
 ) -> Result<[G; OUT_721], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60396,11 +61118,11 @@ fn aiur_fn_721(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_721] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_1]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -60408,28 +61130,28 @@ fn aiur_fn_721(
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(0);
             let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(1);
             let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(2);
             let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(3);
             let __ret: [G; OUT_721] = [__v_4, __v_5, __v_3];
-            if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[721].weight(); } record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -60451,6 +61173,7 @@ fn aiur_fn_722(
   unconstrained: bool,
 ) -> Result<[G; OUT_722], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -60460,19 +61183,19 @@ fn aiur_fn_722(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_722] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[722].weight(); } record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0]; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60491,7 +61214,7 @@ fn aiur_fn_722(
         let __v_25: G = __r_arr[15];
         let __v_26: G = __r_arr[16];
         let __v_27: G = __r_arr[17];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -60500,13 +61223,13 @@ fn aiur_fn_722(
         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_722] = { let __args: [G; IN_722] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[722].replay_at(__i); record.virt += __r; } 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 __v_36: G = __r_arr[0];
         let __v_37: G = __r_arr[1];
         let __v_38: G = G::from_u64(0);
-        let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_722] = [__v_39, __v_37];
-        if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[722].weight(); } record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60523,6 +61246,7 @@ fn aiur_fn_723(
   unconstrained: bool,
 ) -> Result<[G; OUT_723], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60530,11 +61254,11 @@ fn aiur_fn_723(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[723].weight(); } record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60544,12 +61268,12 @@ fn aiur_fn_723(
         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_722] = { let __args: [G; IN_722] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__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[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[722].replay_at(__i); record.virt += __r; } 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 __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_723] = [__v_13, __v_11, __v_12];
-        if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[723].weight(); } record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60566,8 +61290,9 @@ fn aiur_fn_724(
   unconstrained: bool,
 ) -> Result<[G; OUT_724], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60586,11 +61311,11 @@ fn aiur_fn_724(
     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_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_10, __v_9]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
-    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11, __v_20]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -60601,7 +61326,7 @@ fn aiur_fn_724(
     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_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_30]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -60612,7 +61337,7 @@ fn aiur_fn_724(
     let __v_38: G = __r_arr[7];
     let __v_39: G = __r_arr[8];
     let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_40]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -60623,7 +61348,7 @@ fn aiur_fn_724(
     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_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_50]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -60634,12 +61359,12 @@ fn aiur_fn_724(
     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_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_60]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
     let __ret: [G; OUT_724] = [__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];
-    if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[724].weight(); } record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -60654,8 +61379,9 @@ fn aiur_fn_725(
   unconstrained: bool,
 ) -> Result<[G; OUT_725], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60665,7 +61391,7 @@ fn aiur_fn_725(
     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_724] = { let __args: [G; IN_724] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_9]; 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 { let __r = record.function_queries[724].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -60708,7 +61434,7 @@ fn aiur_fn_725(
     let __v_49: G = __r_arr[39];
     let __v_50: G = __r_arr[40];
     let __ret: [G; OUT_725] = [__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];
-    if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[725].weight(); } record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -60723,6 +61449,7 @@ fn aiur_fn_726(
   unconstrained: bool,
 ) -> Result<[G; OUT_726], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -60732,19 +61459,19 @@ fn aiur_fn_726(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_726] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[726].weight(); } record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0]; 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 { let __r = record.function_queries[725].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -60794,7 +61521,7 @@ fn aiur_fn_726(
         let __v_56: G = __r_arr[46];
         let __v_57: G = __r_arr[47];
         let __v_58: G = __r_arr[48];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
         let __v_60: G = __r_arr[1];
         let __v_61: G = __r_arr[2];
@@ -60803,13 +61530,13 @@ fn aiur_fn_726(
         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_726] = { let __args: [G; IN_726] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__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[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[726].replay_at(__i); record.virt += __r; } 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_67: G = __r_arr[0];
         let __v_68: G = __r_arr[1];
         let __v_69: G = G::from_u64(0);
-        let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_726] = [__v_70, __v_68];
-        if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[726].weight(); } record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60826,6 +61553,7 @@ fn aiur_fn_727(
   unconstrained: bool,
 ) -> Result<[G; OUT_727], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
@@ -60833,11 +61561,11 @@ fn aiur_fn_727(
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
         let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1];
-        if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[727].weight(); } record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_1]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -60847,12 +61575,12 @@ fn aiur_fn_727(
         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_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__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[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[726].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
         let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12];
-        if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[727].weight(); } record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -60869,11 +61597,12 @@ fn aiur_fn_728(
   unconstrained: bool,
 ) -> Result<[G; OUT_728], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -60903,15 +61632,15 @@ fn aiur_fn_728(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; 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 { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -60922,26 +61651,26 @@ fn aiur_fn_728(
         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_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_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_728] = [__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];
-        if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -60952,7 +61681,7 @@ fn aiur_fn_728(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_40]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
         let __v_42: G = __r_arr[1];
         let __v_43: G = __r_arr[2];
@@ -60963,7 +61692,7 @@ fn aiur_fn_728(
         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_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_50]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
         let __v_52: G = __r_arr[1];
         let __v_53: G = __r_arr[2];
@@ -60974,30 +61703,30 @@ fn aiur_fn_728(
         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_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_60]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; 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 { let __r = record.function_queries[727].replay_at(__i); record.virt += __r; } 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_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_728] = [__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];
-        if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -61008,7 +61737,7 @@ fn aiur_fn_728(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -61019,7 +61748,7 @@ fn aiur_fn_728(
         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_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -61030,7 +61759,7 @@ fn aiur_fn_728(
         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_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -61041,7 +61770,7 @@ fn aiur_fn_728(
         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_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -61052,17 +61781,17 @@ fn aiur_fn_728(
         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_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
         let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; 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 { let __r = record.function_queries[723].replay_at(__i); record.virt += __r; } 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 __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_728] = [__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];
-        if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[728].weight(); } record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61082,8 +61811,9 @@ fn aiur_fn_729(
   unconstrained: bool,
 ) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -61093,7 +61823,7 @@ fn aiur_fn_729(
     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_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; 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 { let __r = record.function_queries[728].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -61150,7 +61880,7 @@ fn aiur_fn_729(
     let __v_63: G = __r_arr[53];
     let __v_64: G = __r_arr[54];
     let __ret: [G; OUT_729] = [__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];
-    if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[729].weight(); } record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -61165,6 +61895,7 @@ fn aiur_fn_730(
   unconstrained: bool,
 ) -> Result<[G; OUT_730], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -61174,19 +61905,19 @@ fn aiur_fn_730(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_730] = [__v_12, __v_0];
-        if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[730].weight(); } record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[729].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -61250,7 +61981,7 @@ fn aiur_fn_730(
         let __v_70: G = __r_arr[60];
         let __v_71: G = __r_arr[61];
         let __v_72: G = __r_arr[62];
-        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
         let __v_74: G = __r_arr[1];
         let __v_75: G = __r_arr[2];
@@ -61259,13 +61990,13 @@ fn aiur_fn_730(
         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_730] = { let __args: [G; IN_730] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__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[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[730].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
         let __v_82: G = __r_arr[1];
         let __v_83: G = G::from_u64(0);
-        let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_730] = [__v_84, __v_82];
-        if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[730].weight(); } record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -61282,11 +62013,12 @@ fn aiur_fn_731(
   unconstrained: bool,
 ) -> Result<[G; OUT_731], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; 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 { let __r = record.function_queries[73].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_2]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -61316,15 +62048,15 @@ fn aiur_fn_731(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_12, __v_11]; 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 { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_13, __v_30]; 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 { let __r = record.function_queries[720].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -61335,30 +62067,30 @@ fn aiur_fn_731(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_43]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_16, __v_46]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
         let __v_48: G = __r_arr[1];
         let __v_49: G = __r_arr[2];
         let __v_50: G = G::from_u64(0);
         let __v_51: G = G::from_u64(0);
         let __ret: [G; OUT_731] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_13, __v_30]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_14, __v_33]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = __r_arr[2];
@@ -61369,7 +62101,7 @@ fn aiur_fn_731(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_15, __v_43]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
         let __v_46: G = __r_arr[2];
@@ -61380,7 +62112,7 @@ fn aiur_fn_731(
         let __v_51: G = __r_arr[7];
         let __v_52: G = __r_arr[8];
         let __v_53: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_16, __v_53]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = __r_arr[2];
@@ -61391,7 +62123,7 @@ fn aiur_fn_731(
         let __v_61: G = __r_arr[7];
         let __v_62: G = __r_arr[8];
         let __v_63: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_17, __v_63]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
         let __v_65: G = __r_arr[1];
         let __v_66: G = __r_arr[2];
@@ -61402,7 +62134,7 @@ fn aiur_fn_731(
         let __v_71: G = __r_arr[7];
         let __v_72: G = __r_arr[8];
         let __v_73: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_73]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_74: G = __r_arr[0];
         let __v_75: G = __r_arr[1];
         let __v_76: G = __r_arr[2];
@@ -61413,25 +62145,25 @@ fn aiur_fn_731(
         let __v_81: G = __r_arr[7];
         let __v_82: G = __r_arr[8];
         let __v_83: G = __r_arr[9];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_83]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_84: G = __r_arr[0];
         let __v_85: G = __r_arr[1];
         let __v_86: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_20, __v_86]; 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 { let __r = record.function_queries[723].replay_at(__i); record.virt += __r; } 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 __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_731] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_12, __v_11]; 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 { let __r = record.function_queries[719].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -61442,22 +62174,22 @@ fn aiur_fn_731(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; 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 { let __r = record.function_queries[721].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_30]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         let __v_33: G = __r_arr[2];
@@ -61468,18 +62200,18 @@ fn aiur_fn_731(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_40]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61490,7 +62222,7 @@ fn aiur_fn_731(
         let __v_35: G = __r_arr[7];
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_13, __v_37]; 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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
         let __v_40: G = __r_arr[2];
@@ -61501,18 +62233,18 @@ fn aiur_fn_731(
         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_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_47]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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_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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61523,18 +62255,18 @@ fn aiur_fn_731(
         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_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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 __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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61545,18 +62277,18 @@ fn aiur_fn_731(
         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_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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 __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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_12, __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 { let __r = record.function_queries[717].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -61567,14 +62299,14 @@ fn aiur_fn_731(
         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_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_37]; 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 { let __r = record.function_queries[718].replay_at(__i); record.virt += __r; } 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 __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_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       8u64 => {
@@ -61582,11 +62314,11 @@ fn aiur_fn_731(
   0u64 => {
     let __v_28: G = G::from_u64(1);
     let __v_29: G = G::from_u64(1);
-    let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_11]; 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 { let __r = record.function_queries[75].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -61596,7 +62328,7 @@ fn aiur_fn_731(
     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_730] = { let __args: [G; IN_730] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__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[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[730].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     break '__mc_0 [__v_37, __v_38];
@@ -61611,7 +62343,7 @@ fn aiur_fn_731(
         let __v_30: G = G::from_u64(8);
         let __v_31: G = G::from_u64(0);
         let __ret: [G; OUT_731] = [__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];
-        if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[731].weight(); } record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61631,8 +62363,9 @@ fn aiur_fn_732(
   unconstrained: bool,
 ) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+    let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -61653,13 +62386,13 @@ fn aiur_fn_732(
     let __v_18: G = __loaded[17];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(1);
-    let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[22].replay_at(__i); record.virt += __r; } 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_732] = [__v_23];
-    if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[732].weight(); } record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -61674,24 +62407,25 @@ fn aiur_fn_733(
   unconstrained: bool,
 ) -> Result<[G; OUT_733], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_733] = [__v_1];
-        if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
         let __ret: [G; OUT_733] = [__v_1];
-        if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
         let __ret: [G; OUT_733] = [__v_1];
-        if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[733].weight(); } record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61711,25 +62445,26 @@ fn aiur_fn_734(
   unconstrained: bool,
 ) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_734] = [];
-        if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[734].weight(); } record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; 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 { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; 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 { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } 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 __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_734] = [];
-        if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[734].weight(); } record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61749,25 +62484,26 @@ fn aiur_fn_735(
   unconstrained: bool,
 ) -> Result<[G; OUT_735], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_735] = [];
-        if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[735].weight(); } record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; 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 { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2]; 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 { let __r = record.function_queries[733].replay_at(__i); record.virt += __r; } 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 __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_735] = [];
-        if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[735].weight(); } record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61787,25 +62523,26 @@ fn aiur_fn_736(
   unconstrained: bool,
 ) -> Result<[G; OUT_736], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_736] = [];
-        if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[736].weight(); } record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_0]; 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 { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_99(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } } else { aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[100].replay_at(__i); record.virt += __r; } 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 __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_736] = [];
-        if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[736].weight(); } record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61825,13 +62562,14 @@ fn aiur_fn_737(
   unconstrained: bool,
 ) -> Result<[G; OUT_737], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_737] = [];
-        if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[737].weight(); } record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -61839,7 +62577,7 @@ fn aiur_fn_737(
           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_737] = [];
-        if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[737].weight(); } record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61859,6 +62597,7 @@ fn aiur_fn_738(
   unconstrained: bool,
 ) -> Result<[G; OUT_738], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -61879,7 +62618,7 @@ fn aiur_fn_738(
     match __v_8.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_738] = [];
-        if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[738].weight(); } record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -61908,7 +62647,7 @@ fn aiur_fn_738(
           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_738] = [];
-        if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[738].weight(); } record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -61928,17 +62667,18 @@ fn aiur_fn_739(
   unconstrained: bool,
 ) -> Result<[G; OUT_739], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_739] = [];
-        if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[739].weight(); } record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_3: G = __loaded[0];
         let __v_4: G = __loaded[1];
         let __v_5: G = __loaded[2];
@@ -61971,7 +62711,7 @@ fn aiur_fn_739(
         let __v_32: G = __loaded[29];
         let __v_33: G = __loaded[30];
         let __v_34: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_35: G = __loaded[0];
         let __v_36: G = __loaded[1];
         let __v_37: G = __loaded[2];
@@ -62101,7 +62841,7 @@ fn aiur_fn_739(
           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_739] = [];
-        if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[739].weight(); } record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -62121,19 +62861,20 @@ fn aiur_fn_740(
   unconstrained: bool,
 ) -> Result<[G; OUT_740], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_740] = [];
-        if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[740].weight(); } record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_0]; 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 { let __r = record.function_queries[732].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
@@ -62166,7 +62907,7 @@ fn aiur_fn_740(
         let __v_33: G = __loaded[29];
         let __v_34: G = __loaded[30];
         let __v_35: G = __loaded[31];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_36: G = __loaded[0];
         let __v_37: G = __loaded[1];
         let __v_38: G = __loaded[2];
@@ -62296,7 +63037,7 @@ fn aiur_fn_740(
           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_740] = [];
-        if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[740].weight(); } record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -62316,6 +63057,7 @@ fn aiur_fn_741(
   unconstrained: bool,
 ) -> Result<[G; OUT_741], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -62326,7 +63068,7 @@ fn aiur_fn_741(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr };
+    let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
     let __v_11: G = __loaded[1];
     let __v_12: G = __loaded[2];
@@ -62348,7 +63090,7 @@ fn aiur_fn_741(
     let __v_28: G = __loaded[18];
     match __v_10.as_canonical_u64() {
       1u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
         let __v_29: G = __loaded[0];
         let __v_30: G = __loaded[1];
         let __v_31: G = __loaded[2];
@@ -62363,7 +63105,7 @@ fn aiur_fn_741(
         match __v_29.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_741] = [];
-            if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[741].weight(); } record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -62372,7 +63114,7 @@ fn aiur_fn_741(
         }
       },
       0u64 => {
-        let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
         let __v_29: G = __loaded[0];
         let __v_30: G = __loaded[1];
         let __v_31: G = __loaded[2];
@@ -62391,7 +63133,7 @@ fn aiur_fn_741(
                 match __v_30.as_canonical_u64() {
                   _ => {
                     let __v_40: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_38, __v_40, __v_27]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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)? } };
                     if (__v_11 != __v_2) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) });
                     }
@@ -62440,7 +63182,7 @@ fn aiur_fn_741(
                     if (__v_37 != __v_26) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
-                    let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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];
                     let __v_43: G = __r_arr[2];
@@ -62449,9 +63191,9 @@ fn aiur_fn_741(
                     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_741] = { let __args: [G; IN_741] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_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[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[741].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_741] = [];
-                    if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[741].weight(); } record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -62480,13 +63222,14 @@ fn aiur_fn_742(
   unconstrained: bool,
 ) -> Result<[G; OUT_742], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_742] = [];
-        if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[742].weight(); } record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -62498,9 +63241,9 @@ fn aiur_fn_742(
         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_741] = { let __args: [G; IN_741] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_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[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[741].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_742] = [];
-        if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[742].weight(); } record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -62520,6 +63263,7 @@ fn aiur_fn_743(
   unconstrained: bool,
 ) -> Result<[G; OUT_743], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -62569,7 +63313,7 @@ fn aiur_fn_743(
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
     let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__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[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[767].replay_at(__i); record.virt += __r; } 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 __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
     let __v_51: G = __r_arr[2];
@@ -62608,14 +63352,14 @@ fn aiur_fn_743(
       _ => {
         match __v_49.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_9, __v_10]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_82, __v_47, __v_48]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_743] = [];
-            if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[743].weight(); } record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -62634,9 +63378,10 @@ fn aiur_fn_744(
   unconstrained: bool,
 ) -> Result<[G; OUT_744], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr };
+    let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -62690,14 +63435,14 @@ fn aiur_fn_744(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_744] = [];
-        if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[744].weight(); } record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; 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 { let __r = record.function_queries[743].replay_at(__i); record.virt += __r; } 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_744] = { let __args: [G; IN_744] = [__v_0, __v_51]; 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 { let __r = record.function_queries[744].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_744] = [];
-        if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[744].weight(); } record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -62717,19 +63462,20 @@ fn aiur_fn_745(
   unconstrained: bool,
 ) -> Result<[G; OUT_745], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_745] = [];
-        if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[745].weight(); } record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0, __v_2]; 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 { let __r = record.function_queries[744].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_745] = [];
-        if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[745].weight(); } record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -62749,6 +63495,7 @@ fn aiur_fn_746(
   unconstrained: bool,
 ) -> Result<[G; OUT_746], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -62854,13 +63601,13 @@ fn aiur_fn_746(
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_1, __v_46, __v_47]; 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 { let __r = record.function_queries[734].replay_at(__i); record.virt += __r; } 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_735] = { let __args: [G; IN_735] = [__v_2, __v_48, __v_49]; 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 { let __r = record.function_queries[735].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_11, __v_59, __v_60]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_12, __v_61, __v_62]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_746] = [];
-                if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -62875,14 +63622,14 @@ fn aiur_fn_746(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_26, __v_75, __v_76]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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_27, __v_77, __v_78]; 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 { let __r = record.function_queries[745].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_746] = [];
-                if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -62897,17 +63644,17 @@ fn aiur_fn_746(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_1, __v_46, __v_47]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_737] = { let __args: [G; IN_737] = [__v_2, __v_48, __v_49]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_43, __v_95, __v_96]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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_742] = { let __args: [G; IN_742] = [__v_44, __v_97, __v_98]; 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 { let __r = record.function_queries[742].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_746] = [];
-                if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[746].weight(); } record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -62934,9 +63681,10 @@ fn aiur_fn_747(
   unconstrained: bool,
 ) -> Result<[G; OUT_747], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr };
+    let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -63004,11 +63752,11 @@ fn aiur_fn_747(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_747] = [];
-        if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[747].weight(); } record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__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[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } 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 __v_66: G = __r_arr[0];
         let __v_67: G = __r_arr[1];
         let __v_68: G = __r_arr[2];
@@ -63054,10 +63802,10 @@ fn aiur_fn_747(
         let __v_108: G = __r_arr[42];
         let __v_109: G = __r_arr[43];
         let __v_110: G = __r_arr[44];
-        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; 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 { let __r = record.function_queries[746].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_65]; 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 { let __r = record.function_queries[747].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_747] = [];
-        if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[747].weight(); } record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63077,6 +63825,7 @@ fn aiur_fn_748(
   unconstrained: bool,
 ) -> Result<[G; OUT_748], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -63132,7 +63881,7 @@ fn aiur_fn_748(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_0]; 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 { let __r = record.function_queries[279].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
     let __v_56: G = __r_arr[1];
     let __v_57: G = __r_arr[2];
@@ -63189,13 +63938,13 @@ fn aiur_fn_748(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_56, __v_2, __v_3]; 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 { let __r = record.function_queries[734].replay_at(__i); record.virt += __r; } 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_735] = { let __args: [G; IN_735] = [__v_57, __v_4, __v_5]; 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 { let __r = record.function_queries[735].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_66, __v_15, __v_16]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_67, __v_17, __v_18]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63210,17 +63959,17 @@ fn aiur_fn_748(
               1u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_737] = { let __args: [G; IN_737] = [__v_57, __v_4, __v_5]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_98, __v_51, __v_52]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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_742] = { let __args: [G; IN_742] = [__v_99, __v_53, __v_54]; 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 { let __r = record.function_queries[742].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63235,11 +63984,11 @@ fn aiur_fn_748(
               2u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_56, __v_2, __v_3]; 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 { let __r = record.function_queries[737].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63254,11 +64003,11 @@ fn aiur_fn_748(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_56, __v_2, __v_3]; 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 { let __r = record.function_queries[736].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_740] = { let __args: [G; IN_740] = [__v_65, __v_13, __v_14]; 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 { let __r = record.function_queries[740].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63273,11 +64022,11 @@ fn aiur_fn_748(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_738] = { let __args: [G; IN_738] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_739] = { let __args: [G; IN_739] = [__v_72, __v_20, __v_21]; 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 { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63292,10 +64041,10 @@ fn aiur_fn_748(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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 { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63310,10 +64059,10 @@ fn aiur_fn_748(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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 { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63328,10 +64077,10 @@ fn aiur_fn_748(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; 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 { let __r = record.function_queries[738].replay_at(__i); record.virt += __r; } 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_739] = { let __args: [G; IN_739] = [__v_64, __v_11, __v_12]; 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 { let __r = record.function_queries[739].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                    if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -63344,9 +64093,9 @@ fn aiur_fn_748(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2]; 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 { let __r = record.function_queries[747].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_748] = [];
-                if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[748].weight(); } record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -63373,18 +64122,19 @@ fn aiur_fn_749(
   unconstrained: bool,
 ) -> Result<[G; OUT_749], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_1, __v_2]; 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 { let __r = record.function_queries[413].replay_at(__i); record.virt += __r; } 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_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_749] = [];
-    if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[749].weight(); } record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -63399,6 +64149,7 @@ fn aiur_fn_750(
   unconstrained: bool,
 ) -> Result<[G; OUT_750], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -63412,7 +64163,7 @@ fn aiur_fn_750(
     let __v_9: G = __io_pair.0;
     let __v_10: G = __io_pair.1;
     let __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_9, __v_10]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; 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_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(103);
     let __v_14: G = G::from_u64(230);
@@ -63448,7 +64199,7 @@ fn aiur_fn_750(
     let __v_44: G = G::from_u64(91);
     let __v_45: G = G::from_u64(1);
     let __v_46: G = G::from_u64(1);
-    let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_48: G = G::from_u64(0);
     let __v_49: G = G::from_u64(0);
     let __v_50: G = G::from_u64(0);
@@ -63459,14 +64210,14 @@ fn aiur_fn_750(
     let __v_55: G = G::from_u64(0);
     let __v_56: G = G::from_u64(0);
     let __v_57: G = G::from_u64(0);
-    let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_59: 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_60: G = G::from_u64(1);
     let __v_61: G = G::from_u64(1);
-    let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
+    let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_63: G = __r_arr[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[24].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__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];
@@ -63499,7 +64250,7 @@ fn aiur_fn_750(
     let __v_93: G = __r_arr[29];
     let __v_94: G = __r_arr[30];
     let __v_95: G = __r_arr[31];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
     let __v_97: G = __r_arr[1];
     let __v_98: G = __r_arr[2];
@@ -63622,26 +64373,26 @@ fn aiur_fn_750(
     }
     match __v_97.as_canonical_u64() {
       4u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; 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 { let __r = record.function_queries[716].replay_at(__i); record.virt += __r; } 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_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() {
           1u64 => {
-            let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_186]; 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 { let __r = record.function_queries[702].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_750] = [];
-            if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_189]; 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 { let __r = record.function_queries[709].replay_at(__i); record.virt += __r; } 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 __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_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; 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 { let __r = record.function_queries[710].replay_at(__i); record.virt += __r; } 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_194: G = __r_arr[0];
             let __v_195: G = __r_arr[1];
             let __v_196: G = __r_arr[2];
@@ -63651,9 +64402,9 @@ fn aiur_fn_750(
             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_712] = { let __args: [G; IN_712] = [__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; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_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[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[712].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_750] = [];
-            if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -63662,23 +64413,23 @@ fn aiur_fn_750(
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_187]; 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 { let __r = record.function_queries[716].replay_at(__i); record.virt += __r; } 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_188: G = __r_arr[0];
         let __v_189: G = __r_arr[1];
         let __v_190: G = __r_arr[2];
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_186, __v_188, __v_189]; 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 { let __r = record.function_queries[715].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_750] = [];
-        if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_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; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[731].replay_at(__i); record.virt += __r; } 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];
@@ -63734,21 +64485,21 @@ fn aiur_fn_750(
         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_748] = { let __args: [G; IN_748] = [__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; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__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[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[748].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_750] = [];
-        if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_105]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_186: G = __r_arr[0];
         let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_187]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_188: G = __r_arr[0];
         let __v_189: G = __r_arr[1];
-        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_186, __v_188]; 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 { let __r = record.function_queries[749].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_750] = [];
-        if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[750].weight(); } record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63768,6 +64519,7 @@ fn aiur_fn_751(
   unconstrained: bool,
 ) -> Result<[G; OUT_751], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -63776,9 +64528,9 @@ fn aiur_fn_751(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 { let __r = record.function_queries[750].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_751] = [];
-    if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[751].weight(); } record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -63793,24 +64545,25 @@ fn aiur_fn_752(
   unconstrained: bool,
 ) -> Result<[G; OUT_752], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_3: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_5: G = __loaded[1];
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_752] = [__v_2];
-        if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[752].weight(); } record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __ret: [G; OUT_752] = [__v_5];
-        if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[752].weight(); } record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63830,9 +64583,10 @@ fn aiur_fn_753(
   unconstrained: bool,
 ) -> Result<[G; OUT_753], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -63841,19 +64595,19 @@ fn aiur_fn_753(
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_753] = [__v_9];
-        if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[753].weight(); } record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_4, __v_1]; 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 { let __r = record.function_queries[753].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_753] = [__v_7];
-        if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[753].weight(); } record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63873,8 +64627,9 @@ fn aiur_fn_754(
   unconstrained: bool,
 ) -> Result<[G; OUT_754], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -63896,11 +64651,11 @@ fn aiur_fn_754(
         let __v_17: G = G::from_u64(0);
         let __v_18: G = G::from_u64(0);
         let __ret: [G; OUT_754] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[754].weight(); } record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_10]; 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 { let __r = record.function_queries[754].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -63909,7 +64664,7 @@ fn aiur_fn_754(
         let __v_16: G = __r_arr[5];
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -63919,7 +64674,7 @@ fn aiur_fn_754(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __ret: [G; OUT_754] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[754].weight(); } record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63939,9 +64694,10 @@ fn aiur_fn_755(
   unconstrained: bool,
 ) -> Result<[G; OUT_755], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -63949,16 +64705,16 @@ fn aiur_fn_755(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_755] = [__v_1];
-        if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[755].weight(); } record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_5, __v_1]; 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 { let __r = record.function_queries[755].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_755] = [__v_8];
-        if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[755].weight(); } record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -63978,8 +64734,9 @@ fn aiur_fn_756(
   unconstrained: bool,
 ) -> Result<[G; OUT_756], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -63994,11 +64751,11 @@ fn aiur_fn_756(
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
         let __ret: [G; OUT_756] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[756].weight(); } record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__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 { let __r = record.function_queries[756].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         let __v_6: G = __r_arr[2];
@@ -64007,7 +64764,7 @@ fn aiur_fn_756(
         let __v_9: G = __r_arr[5];
         let __v_10: G = __r_arr[6];
         let __v_11: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64017,7 +64774,7 @@ fn aiur_fn_756(
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
         let __ret: [G; OUT_756] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[756].weight(); } record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64037,6 +64794,7 @@ fn aiur_fn_757(
   unconstrained: bool,
 ) -> Result<[G; OUT_757], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -64048,18 +64806,18 @@ fn aiur_fn_757(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_757] = [__v_7];
-        if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
         let __v_12: G = __loaded[4];
         let __v_13: G = __loaded[5];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_14: G = __loaded[0];
         let __v_15: G = __loaded[1];
         let __v_16: G = __loaded[2];
@@ -64069,10 +64827,10 @@ fn aiur_fn_757(
         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_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; 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 { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } 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 __v_21: G = __r_arr[0];
             let __ret: [G; OUT_757] = [__v_21];
-            if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -64080,14 +64838,14 @@ fn aiur_fn_757(
             match __v_21.as_canonical_u64() {
               0u64 => {
                 let __ret: [G; OUT_757] = [__v_4];
-                if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; 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 { let __r = record.function_queries[757].replay_at(__i); record.virt += __r; } 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 __v_22: G = __r_arr[0];
                 let __ret: [G; OUT_757] = [__v_22];
-                if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[757].weight(); } record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -64111,14 +64869,15 @@ fn aiur_fn_758(
   unconstrained: bool,
 ) -> Result<[G; OUT_758], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(1);
-    let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0, __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 { let __r = record.function_queries[776].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_758] = [__v_4];
-    if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[758].weight(); } record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -64133,25 +64892,26 @@ fn aiur_fn_759(
   unconstrained: bool,
 ) -> Result<[G; OUT_759], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_759] = [__v_1];
-        if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[759].weight(); } record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_4, __v_1]; 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 { let __r = record.function_queries[759].replay_at(__i); record.virt += __r; } 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 __v_6: G = __r_arr[0];
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_759] = [__v_7];
-        if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[759].weight(); } record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64171,8 +64931,9 @@ fn aiur_fn_760(
   unconstrained: bool,
 ) -> Result<[G; OUT_760], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -64180,16 +64941,16 @@ fn aiur_fn_760(
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_760] = [__v_4];
-        if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[760].weight(); } record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; 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 { let __r = record.function_queries[760].replay_at(__i); record.virt += __r; } 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 __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_760] = [__v_6];
-        if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[760].weight(); } record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64209,8 +64970,9 @@ fn aiur_fn_761(
   unconstrained: bool,
 ) -> Result<[G; OUT_761], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -64258,11 +65020,11 @@ fn aiur_fn_761(
         let __v_43: G = G::from_u64(0);
         let __v_44: G = G::from_u64(0);
         let __ret: [G; OUT_761] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[761].weight(); } record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_36]; 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 { let __r = record.function_queries[761].replay_at(__i); record.virt += __r; } 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 __v_37: G = __r_arr[0];
         let __v_38: G = __r_arr[1];
         let __v_39: G = __r_arr[2];
@@ -64271,7 +65033,7 @@ fn aiur_fn_761(
         let __v_42: G = __r_arr[5];
         let __v_43: G = __r_arr[6];
         let __v_44: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
         let __v_46: G = __r_arr[1];
         let __v_47: G = __r_arr[2];
@@ -64281,7 +65043,7 @@ fn aiur_fn_761(
         let __v_51: G = __r_arr[6];
         let __v_52: G = __r_arr[7];
         let __ret: [G; OUT_761] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[761].weight(); } record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64301,18 +65063,19 @@ fn aiur_fn_762(
   unconstrained: bool,
 ) -> Result<[G; OUT_762], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1]; 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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_762] = [__v_4];
-        if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[762].weight(); } record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64332,8 +65095,9 @@ fn aiur_fn_763(
   unconstrained: bool,
 ) -> Result<[G; OUT_763], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -64348,16 +65112,16 @@ fn aiur_fn_763(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __ret: [G; OUT_763] = [__v_11];
-        if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[763].weight(); } record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_10]; 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 { let __r = record.function_queries[763].replay_at(__i); record.virt += __r; } 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 __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_763] = [__v_13];
-        if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[763].weight(); } record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64377,6 +65141,7 @@ fn aiur_fn_764(
   unconstrained: bool,
 ) -> Result<[G; OUT_764], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -64386,7 +65151,7 @@ fn aiur_fn_764(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -64436,16 +65201,16 @@ fn aiur_fn_764(
     let __v_55: G = __loaded[46];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_764] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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];
-            if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[764].weight(); } record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
             let __v_59: G = __r_arr[2];
@@ -64454,7 +65219,7 @@ fn aiur_fn_764(
             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_764] = { let __args: [G; IN_764] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__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[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[764].replay_at(__i); record.virt += __r; } 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 __v_65: G = __r_arr[0];
             let __v_66: G = __r_arr[1];
             let __v_67: G = __r_arr[2];
@@ -64501,7 +65266,7 @@ fn aiur_fn_764(
             let __v_108: G = __r_arr[43];
             let __v_109: G = __r_arr[44];
             let __ret: [G; OUT_764] = [__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];
-            if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[764].weight(); } record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -64526,8 +65291,9 @@ fn aiur_fn_765(
   unconstrained: bool,
 ) -> Result<[G; OUT_765], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -64586,11 +65352,11 @@ fn aiur_fn_765(
         let __v_54: G = G::from_u64(0);
         let __v_55: G = G::from_u64(0);
         let __ret: [G; OUT_765] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[765].weight(); } record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_47]; 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 { let __r = record.function_queries[765].replay_at(__i); record.virt += __r; } 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 __v_48: G = __r_arr[0];
         let __v_49: G = __r_arr[1];
         let __v_50: G = __r_arr[2];
@@ -64599,7 +65365,7 @@ fn aiur_fn_765(
         let __v_53: G = __r_arr[5];
         let __v_54: G = __r_arr[6];
         let __v_55: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
         let __v_57: G = __r_arr[1];
         let __v_58: G = __r_arr[2];
@@ -64609,7 +65375,7 @@ fn aiur_fn_765(
         let __v_62: G = __r_arr[6];
         let __v_63: G = __r_arr[7];
         let __ret: [G; OUT_765] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[765].weight(); } record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64629,8 +65395,9 @@ fn aiur_fn_766(
   unconstrained: bool,
 ) -> Result<[G; OUT_766], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -64653,11 +65420,11 @@ fn aiur_fn_766(
         let __v_18: G = G::from_u64(0);
         let __v_19: G = G::from_u64(0);
         let __ret: [G; OUT_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[766].weight(); } record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11]; 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 { let __r = record.function_queries[766].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -64666,7 +65433,7 @@ fn aiur_fn_766(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_14(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } } else { aiur_fn_14(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; 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 { let __r = record.function_queries[15].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = __r_arr[2];
@@ -64676,7 +65443,7 @@ fn aiur_fn_766(
         let __v_26: G = __r_arr[6];
         let __v_27: G = __r_arr[7];
         let __ret: [G; OUT_766] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[766].weight(); } record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64696,6 +65463,7 @@ fn aiur_fn_767(
   unconstrained: bool,
 ) -> Result<[G; OUT_767], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -64705,7 +65473,7 @@ fn aiur_fn_767(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -64744,16 +65512,16 @@ fn aiur_fn_767(
     let __v_44: G = __loaded[35];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[4].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_4(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_4] = unsafe { *(result.output.as_ptr() as *const [G; OUT_4]) }; __ret } } else { aiur_fn_4(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[5].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
             let __ret: [G; OUT_767] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
-            if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[767].weight(); } record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_15(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } } else { aiur_fn_15(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_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 { let __r = record.function_queries[16].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
             let __v_47: G = __r_arr[1];
             let __v_48: G = __r_arr[2];
@@ -64762,7 +65530,7 @@ fn aiur_fn_767(
             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_767] = { let __args: [G; IN_767] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__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[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[767].replay_at(__i); record.virt += __r; } 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 __v_54: G = __r_arr[0];
             let __v_55: G = __r_arr[1];
             let __v_56: G = __r_arr[2];
@@ -64798,7 +65566,7 @@ fn aiur_fn_767(
             let __v_86: G = __r_arr[32];
             let __v_87: G = __r_arr[33];
             let __ret: [G; OUT_767] = [__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];
-            if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[767].weight(); } record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -64823,8 +65591,9 @@ fn aiur_fn_768(
   unconstrained: bool,
 ) -> Result<[G; OUT_768], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
@@ -64832,13 +65601,13 @@ fn aiur_fn_768(
       1u64 => {
         let __v_4: G = G::from_u64(1);
         let __ret: [G; OUT_768] = [__v_4];
-        if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[768].weight(); } record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __ret: [G; OUT_768] = [__v_4];
-        if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[768].weight(); } record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64858,12 +65627,13 @@ fn aiur_fn_769(
   unconstrained: bool,
 ) -> Result<[G; OUT_769], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_5: G = __loaded[0];
     let __v_6: G = __loaded[1];
     let __v_7: G = __loaded[2];
@@ -64875,19 +65645,19 @@ fn aiur_fn_769(
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(1);
         let __v_13: G = G::from_u64(1);
-        let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_769] = [__v_15];
-        if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[769].weight(); } record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[769].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[0];
-        let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_769] = [__v_13];
-        if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[769].weight(); } record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -64907,19 +65677,20 @@ fn aiur_fn_770(
   unconstrained: bool,
 ) -> Result<[G; OUT_770], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_770] = [__v_4];
-        if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[770].weight(); } record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_2: G = __loaded[0];
         let __v_3: G = __loaded[1];
         let __v_4: G = __loaded[2];
@@ -64928,11 +65699,11 @@ fn aiur_fn_770(
             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_770] = { let __args: [G; IN_770] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4, __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 { let __r = record.function_queries[770].replay_at(__i); record.virt += __r; } 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 __v_8: G = __r_arr[0];
-            let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_770] = [__v_9];
-            if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[770].weight(); } record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -64954,27 +65725,28 @@ fn aiur_fn_771(
   unconstrained: bool,
 ) -> Result<[G; OUT_771], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __ret: [G; OUT_771] = [__v_0];
-        if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[771].weight(); } record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __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 { let __r = record.function_queries[771].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __ret: [G; OUT_771] = [__v_7];
-            if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[771].weight(); } record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -64996,8 +65768,9 @@ fn aiur_fn_772(
   unconstrained: bool,
 ) -> Result<[G; OUT_772], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -65007,16 +65780,16 @@ fn aiur_fn_772(
       1u64 => {
         let __v_6: G = G::from_u64(0);
         let __ret: [G; OUT_772] = [__v_6];
-        if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[772].weight(); } record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5]; 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 { let __r = record.function_queries[772].replay_at(__i); record.virt += __r; } 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_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_772] = [__v_8];
-        if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[772].weight(); } record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -65036,6 +65809,7 @@ fn aiur_fn_773(
   unconstrained: bool,
 ) -> Result<[G; OUT_773], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -65044,7 +65818,7 @@ fn aiur_fn_773(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } 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 __v_9: G = __r_arr[1];
     let __v_10: G = __r_arr[2];
@@ -65056,7 +65830,7 @@ fn aiur_fn_773(
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(1);
         let __ret: [G; OUT_773] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[773].weight(); } record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -65076,6 +65850,7 @@ fn aiur_fn_774(
   unconstrained: bool,
 ) -> Result<[G; OUT_774], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -65085,7 +65860,7 @@ fn aiur_fn_774(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
     let __v_10: G = __loaded[1];
     let __v_11: G = __loaded[2];
@@ -65101,19 +65876,19 @@ fn aiur_fn_774(
         let __v_19: G = G::from_u64(0);
         let __v_20: G = G::from_u64(1);
         let __v_21: G = G::from_u64(1);
-        let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_774] = [__v_23];
-        if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[774].weight(); } record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_19: G = G::from_u64(0);
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[774].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-        let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_774] = [__v_21];
-        if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[774].weight(); } record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -65133,8 +65908,9 @@ fn aiur_fn_775(
   unconstrained: bool,
 ) -> Result<[G; OUT_775], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -65145,16 +65921,16 @@ fn aiur_fn_775(
       1u64 => {
         let __v_7: G = G::from_u64(0);
         let __ret: [G; OUT_775] = [__v_7];
-        if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[775].weight(); } record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[775].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
         let __v_9: G = (__v_7 + __v_8);
         let __ret: [G; OUT_775] = [__v_9];
-        if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[775].weight(); } record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -65174,25 +65950,26 @@ fn aiur_fn_776(
   unconstrained: bool,
 ) -> Result<[G; OUT_776], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_776] = [__v_1];
-        if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[776].weight(); } record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __v_6: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_4, __v_6]; 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 { let __r = record.function_queries[776].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __ret: [G; OUT_776] = [__v_7];
-        if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[776].weight(); } record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -65212,6 +65989,7 @@ fn aiur_fn_777(
   unconstrained: bool,
 ) -> Result<[G; OUT_777], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -65226,23 +66004,23 @@ fn aiur_fn_777(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_13: G = G::from_u64(1);
         let __v_14: G = G::from_u64(1);
-        let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_777] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
         let __v_12: G = __loaded[4];
         let __v_13: G = __loaded[5];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_14: G = __loaded[0];
         let __v_15: G = __loaded[1];
         let __v_16: G = __loaded[2];
@@ -65252,14 +66030,14 @@ fn aiur_fn_777(
         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_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __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 { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } 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 __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_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__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[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[778].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
             let __v_28: G = __r_arr[1];
             let __v_29: G = __r_arr[2];
@@ -65267,7 +66045,7 @@ fn aiur_fn_777(
             let __v_31: G = __r_arr[4];
             let __v_32: G = __r_arr[5];
             let __ret: [G; OUT_777] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -65275,21 +66053,21 @@ fn aiur_fn_777(
             match __v_21.as_canonical_u64() {
               0u64 => {
                 let __v_22: G = G::from_u64(0);
-                let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_777] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __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 { let __r = record.function_queries[777].replay_at(__i); record.virt += __r; } 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 __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_778] = { let __args: [G; IN_778] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__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[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[778].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
                 let __v_29: G = __r_arr[1];
                 let __v_30: G = __r_arr[2];
@@ -65297,7 +66075,7 @@ fn aiur_fn_777(
                 let __v_32: G = __r_arr[4];
                 let __v_33: G = __r_arr[5];
                 let __ret: [G; OUT_777] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[777].weight(); } record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -65321,6 +66099,7 @@ fn aiur_fn_778(
   unconstrained: bool,
 ) -> Result<[G; OUT_778], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -65338,7 +66117,7 @@ fn aiur_fn_778(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_1, __v_2, __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[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[779].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         let __v_17: G = __r_arr[2];
@@ -65346,15 +66125,15 @@ fn aiur_fn_778(
         let __v_19: G = __r_arr[4];
         let __v_20: G = __r_arr[5];
         let __ret: [G; OUT_778] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[778].weight(); } record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_778] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[778].weight(); } record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -65371,6 +66150,7 @@ fn aiur_fn_779(
   unconstrained: bool,
 ) -> Result<[G; OUT_779], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -65389,7 +66169,7 @@ fn aiur_fn_779(
       0u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
             let __v_14: G = __loaded[0];
             let __v_15: G = __loaded[1];
             let __v_16: G = __loaded[2];
@@ -65404,17 +66184,17 @@ fn aiur_fn_779(
                     let __v_21: G = G::from_u64(0);
                     let __v_22: G = G::from_u64(0);
                     let __v_23: G = G::from_u64(1);
-                    let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __v_25: G = G::from_u64(0);
                     let __v_26: G = G::from_u64(1);
-                    let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_779] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                     let __v_20: G = __loaded[0];
                     let __v_21: G = __loaded[1];
                     let __v_22: G = __loaded[2];
@@ -65429,13 +66209,13 @@ fn aiur_fn_779(
                             let __v_27: G = G::from_u64(0);
                             let __v_28: G = G::from_u64(0);
                             let __v_29: G = G::from_u64(1);
-                            let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __v_31: G = G::from_u64(0);
                             let __v_32: G = G::from_u64(1);
-                            let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
@@ -65443,7 +66223,7 @@ fn aiur_fn_779(
                               0u64 => {
                                 match __v_9.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                     let __v_26: G = __loaded[0];
                                     let __v_27: G = __loaded[1];
                                     let __v_28: G = __loaded[2];
@@ -65458,17 +66238,17 @@ fn aiur_fn_779(
                                             let __v_33: G = G::from_u64(0);
                                             let __v_34: G = G::from_u64(0);
                                             let __v_35: G = G::from_u64(1);
-                                            let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                             let __v_32: G = __loaded[0];
                                             let __v_33: G = __loaded[1];
                                             let __v_34: G = __loaded[2];
@@ -65483,22 +66263,22 @@ fn aiur_fn_779(
                                                     let __v_39: G = G::from_u64(0);
                                                     let __v_40: G = G::from_u64(0);
                                                     let __v_41: G = G::from_u64(1);
-                                                    let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                    let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                     let __v_44: G = G::from_u64(0);
                                                     let __v_45: G = G::from_u64(1);
-                                                    let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                     let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
                                                     let __v_38: G = G::from_u64(0);
                                                     let __v_39: G = G::from_u64(1);
-                                                    let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                     let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -65506,10 +66286,10 @@ fn aiur_fn_779(
                                               _ => {
                                                 let __v_38: G = G::from_u64(0);
                                                 let __v_39: G = G::from_u64(1);
-                                                let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -65517,7 +66297,7 @@ fn aiur_fn_779(
                                         }
                                       },
                                       _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                         let __v_32: G = __loaded[0];
                                         let __v_33: G = __loaded[1];
                                         let __v_34: G = __loaded[2];
@@ -65532,22 +66312,22 @@ fn aiur_fn_779(
                                                 let __v_39: G = G::from_u64(0);
                                                 let __v_40: G = G::from_u64(0);
                                                 let __v_41: G = G::from_u64(1);
-                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
-                                                let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                               _ => {
                                                 let __v_38: G = G::from_u64(0);
                                                 let __v_39: G = G::from_u64(1);
-                                                let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -65555,10 +66335,10 @@ fn aiur_fn_779(
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65568,10 +66348,10 @@ fn aiur_fn_779(
                                   _ => {
                                     let __v_26: G = G::from_u64(0);
                                     let __v_27: G = G::from_u64(1);
-                                    let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -65579,10 +66359,10 @@ fn aiur_fn_779(
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -65594,7 +66374,7 @@ fn aiur_fn_779(
                           0u64 => {
                             match __v_9.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                 let __v_26: G = __loaded[0];
                                 let __v_27: G = __loaded[1];
                                 let __v_28: G = __loaded[2];
@@ -65609,17 +66389,17 @@ fn aiur_fn_779(
                                         let __v_33: G = G::from_u64(0);
                                         let __v_34: G = G::from_u64(0);
                                         let __v_35: G = G::from_u64(1);
-                                        let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                         let __v_32: G = __loaded[0];
                                         let __v_33: G = __loaded[1];
                                         let __v_34: G = __loaded[2];
@@ -65634,22 +66414,22 @@ fn aiur_fn_779(
                                                 let __v_39: G = G::from_u64(0);
                                                 let __v_40: G = G::from_u64(0);
                                                 let __v_41: G = G::from_u64(1);
-                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
-                                                let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                               _ => {
                                                 let __v_38: G = G::from_u64(0);
                                                 let __v_39: G = G::from_u64(1);
-                                                let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -65657,10 +66437,10 @@ fn aiur_fn_779(
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65668,7 +66448,7 @@ fn aiur_fn_779(
                                     }
                                   },
                                   _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                     let __v_32: G = __loaded[0];
                                     let __v_33: G = __loaded[1];
                                     let __v_34: G = __loaded[2];
@@ -65683,22 +66463,22 @@ fn aiur_fn_779(
                                             let __v_39: G = G::from_u64(0);
                                             let __v_40: G = G::from_u64(0);
                                             let __v_41: G = G::from_u64(1);
-                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
-                                            let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65706,10 +66486,10 @@ fn aiur_fn_779(
                                       _ => {
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
@@ -65719,10 +66499,10 @@ fn aiur_fn_779(
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -65730,10 +66510,10 @@ fn aiur_fn_779(
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -65743,7 +66523,7 @@ fn aiur_fn_779(
                 }
               },
               _ => {
-                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                 let __v_20: G = __loaded[0];
                 let __v_21: G = __loaded[1];
                 let __v_22: G = __loaded[2];
@@ -65758,13 +66538,13 @@ fn aiur_fn_779(
                         let __v_27: G = G::from_u64(0);
                         let __v_28: G = G::from_u64(0);
                         let __v_29: G = G::from_u64(1);
-                        let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __v_31: G = G::from_u64(0);
                         let __v_32: G = G::from_u64(1);
-                        let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_779] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
@@ -65772,7 +66552,7 @@ fn aiur_fn_779(
                           0u64 => {
                             match __v_9.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                 let __v_26: G = __loaded[0];
                                 let __v_27: G = __loaded[1];
                                 let __v_28: G = __loaded[2];
@@ -65787,17 +66567,17 @@ fn aiur_fn_779(
                                         let __v_33: G = G::from_u64(0);
                                         let __v_34: G = G::from_u64(0);
                                         let __v_35: G = G::from_u64(1);
-                                        let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                         let __v_32: G = __loaded[0];
                                         let __v_33: G = __loaded[1];
                                         let __v_34: G = __loaded[2];
@@ -65812,22 +66592,22 @@ fn aiur_fn_779(
                                                 let __v_39: G = G::from_u64(0);
                                                 let __v_40: G = G::from_u64(0);
                                                 let __v_41: G = G::from_u64(1);
-                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __v_44: G = G::from_u64(0);
                                                 let __v_45: G = G::from_u64(1);
-                                                let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                               _ => {
                                                 let __v_38: G = G::from_u64(0);
                                                 let __v_39: G = G::from_u64(1);
-                                                let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                                 let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -65835,10 +66615,10 @@ fn aiur_fn_779(
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65846,7 +66626,7 @@ fn aiur_fn_779(
                                     }
                                   },
                                   _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                     let __v_32: G = __loaded[0];
                                     let __v_33: G = __loaded[1];
                                     let __v_34: G = __loaded[2];
@@ -65861,22 +66641,22 @@ fn aiur_fn_779(
                                             let __v_39: G = G::from_u64(0);
                                             let __v_40: G = G::from_u64(0);
                                             let __v_41: G = G::from_u64(1);
-                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
-                                            let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65884,10 +66664,10 @@ fn aiur_fn_779(
                                       _ => {
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
@@ -65897,10 +66677,10 @@ fn aiur_fn_779(
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -65908,10 +66688,10 @@ fn aiur_fn_779(
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -65923,7 +66703,7 @@ fn aiur_fn_779(
                       0u64 => {
                         match __v_9.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                             let __v_26: G = __loaded[0];
                             let __v_27: G = __loaded[1];
                             let __v_28: G = __loaded[2];
@@ -65938,17 +66718,17 @@ fn aiur_fn_779(
                                     let __v_33: G = G::from_u64(0);
                                     let __v_34: G = G::from_u64(0);
                                     let __v_35: G = G::from_u64(1);
-                                    let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                    let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_38: G = G::from_u64(0);
                                     let __v_39: G = G::from_u64(1);
-                                    let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_779] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                     let __v_32: G = __loaded[0];
                                     let __v_33: G = __loaded[1];
                                     let __v_34: G = __loaded[2];
@@ -65963,22 +66743,22 @@ fn aiur_fn_779(
                                             let __v_39: G = G::from_u64(0);
                                             let __v_40: G = G::from_u64(0);
                                             let __v_41: G = G::from_u64(1);
-                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __v_44: G = G::from_u64(0);
                                             let __v_45: G = G::from_u64(1);
-                                            let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
                                             let __v_38: G = G::from_u64(0);
                                             let __v_39: G = G::from_u64(1);
-                                            let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                             let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
@@ -65986,10 +66766,10 @@ fn aiur_fn_779(
                                       _ => {
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
@@ -65997,7 +66777,7 @@ fn aiur_fn_779(
                                 }
                               },
                               _ => {
-                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                                 let __v_32: G = __loaded[0];
                                 let __v_33: G = __loaded[1];
                                 let __v_34: G = __loaded[2];
@@ -66012,22 +66792,22 @@ fn aiur_fn_779(
                                         let __v_39: G = G::from_u64(0);
                                         let __v_40: G = G::from_u64(0);
                                         let __v_41: G = G::from_u64(1);
-                                        let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __v_44: G = G::from_u64(0);
                                         let __v_45: G = G::from_u64(1);
-                                        let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
                                         let __v_38: G = G::from_u64(0);
                                         let __v_39: G = G::from_u64(1);
-                                        let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                         let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
@@ -66035,10 +66815,10 @@ fn aiur_fn_779(
                                   _ => {
                                     let __v_38: G = G::from_u64(0);
                                     let __v_39: G = G::from_u64(1);
-                                    let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_779] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -66048,10 +66828,10 @@ fn aiur_fn_779(
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -66059,10 +66839,10 @@ fn aiur_fn_779(
                       _ => {
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(1);
-                        let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -66076,7 +66856,7 @@ fn aiur_fn_779(
               0u64 => {
                 match __v_9.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                     let __v_14: G = __loaded[0];
                     let __v_15: G = __loaded[1];
                     let __v_16: G = __loaded[2];
@@ -66091,17 +66871,17 @@ fn aiur_fn_779(
                             let __v_21: G = G::from_u64(0);
                             let __v_22: G = G::from_u64(0);
                             let __v_23: G = G::from_u64(1);
-                            let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                            let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                             let __v_20: G = __loaded[0];
                             let __v_21: G = __loaded[1];
                             let __v_22: G = __loaded[2];
@@ -66116,22 +66896,22 @@ fn aiur_fn_779(
                                     let __v_27: G = G::from_u64(0);
                                     let __v_28: G = G::from_u64(0);
                                     let __v_29: G = G::from_u64(1);
-                                    let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                    let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __v_32: G = G::from_u64(0);
                                     let __v_33: G = G::from_u64(1);
-                                    let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_26: G = G::from_u64(0);
                                     let __v_27: G = G::from_u64(1);
-                                    let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                     let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -66139,10 +66919,10 @@ fn aiur_fn_779(
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -66150,7 +66930,7 @@ fn aiur_fn_779(
                         }
                       },
                       _ => {
-                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                         let __v_20: G = __loaded[0];
                         let __v_21: G = __loaded[1];
                         let __v_22: G = __loaded[2];
@@ -66165,22 +66945,22 @@ fn aiur_fn_779(
                                 let __v_27: G = G::from_u64(0);
                                 let __v_28: G = G::from_u64(0);
                                 let __v_29: G = G::from_u64(1);
-                                let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(1);
-                                let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -66188,10 +66968,10 @@ fn aiur_fn_779(
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -66201,10 +66981,10 @@ fn aiur_fn_779(
                   _ => {
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(1);
-                    let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                     let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -66212,10 +66992,10 @@ fn aiur_fn_779(
               _ => {
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -66227,7 +67007,7 @@ fn aiur_fn_779(
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                 let __v_14: G = __loaded[0];
                 let __v_15: G = __loaded[1];
                 let __v_16: G = __loaded[2];
@@ -66242,17 +67022,17 @@ fn aiur_fn_779(
                         let __v_21: G = G::from_u64(0);
                         let __v_22: G = G::from_u64(0);
                         let __v_23: G = G::from_u64(1);
-                        let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(1);
-                        let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_779] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                         let __v_20: G = __loaded[0];
                         let __v_21: G = __loaded[1];
                         let __v_22: G = __loaded[2];
@@ -66267,22 +67047,22 @@ fn aiur_fn_779(
                                 let __v_27: G = G::from_u64(0);
                                 let __v_28: G = G::from_u64(0);
                                 let __v_29: G = G::from_u64(1);
-                                let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __v_32: G = G::from_u64(0);
                                 let __v_33: G = G::from_u64(1);
-                                let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_26: G = G::from_u64(0);
                                 let __v_27: G = G::from_u64(1);
-                                let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                                 let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -66290,10 +67070,10 @@ fn aiur_fn_779(
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -66301,7 +67081,7 @@ fn aiur_fn_779(
                     }
                   },
                   _ => {
-                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
                     let __v_20: G = __loaded[0];
                     let __v_21: G = __loaded[1];
                     let __v_22: G = __loaded[2];
@@ -66316,22 +67096,22 @@ fn aiur_fn_779(
                             let __v_27: G = G::from_u64(0);
                             let __v_28: G = G::from_u64(0);
                             let __v_29: G = G::from_u64(1);
-                            let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __v_32: G = G::from_u64(0);
                             let __v_33: G = G::from_u64(1);
-                            let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_26: G = G::from_u64(0);
                             let __v_27: G = G::from_u64(1);
-                            let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                             let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -66339,10 +67119,10 @@ fn aiur_fn_779(
                       _ => {
                         let __v_26: G = G::from_u64(0);
                         let __v_27: G = G::from_u64(1);
-                        let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                         let __ret: [G; OUT_779] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -66352,10 +67132,10 @@ fn aiur_fn_779(
               _ => {
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(1);
-                let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -66363,10 +67143,10 @@ fn aiur_fn_779(
           _ => {
             let __v_14: G = G::from_u64(0);
             let __v_15: G = G::from_u64(1);
-            let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+            let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
             let __ret: [G; OUT_779] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            if !unconstrained { record.virt += record.function_queries[779].weight(); } record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
diff --git a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs
index 325ad48c4..b7ac4647e 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs
@@ -24,20 +24,23 @@ use aiur::execute::{ExecError, IOBuffer, QueryRecord};
 /// Rust kernel. Deep recursion is handled via per-fn
 /// `stacker::maybe_grow` checks in the generated code — no
 /// pre-reserved giant stack on this thread, no scope dance.
-// `args: Vec<G>` mirrors `Toplevel::execute`'s signature so this fn
-// can be used as an `impl Fn(&Toplevel, _, Vec<G>, _) -> _` in
-// `AiurSystem::prove_ixvm` — a `&[G]` here would break that bound.
+// `args: Vec<G>` mirrors `Toplevel::execute`'s signature so a
+// `|t, f, a, io| execute_ixvm(t, f, a, io, false)` closure satisfies
+// `AiurSystem::prove_ixvm`'s executor bound — a `&[G]` here would
+// break it. `profile` enables per-entry virtual-span recording on the
+// returned `QueryRecord` (see `aiur::querymap::QueryMap::finish`).
 #[allow(clippy::needless_pass_by_value)]
 pub fn execute_ixvm(
   toplevel: &Toplevel,
   fun_idx: FunIdx,
   args: Vec<G>,
   io_buffer: &mut IOBuffer,
+  profile: bool,
 ) -> Result<(QueryRecord, Vec<G>), ExecError> {
   if !toplevel.functions[fun_idx].entry {
     return Err(ExecError::NotEntryFunction(fun_idx));
   }
-  let mut record = QueryRecord::new(toplevel);
+  let mut record = QueryRecord::new(toplevel, profile);
   let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?;
   Ok((record, output))
 }
diff --git a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
index a194b0f94..67d3a95c5 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm_witness.rs
@@ -75,7 +75,9 @@ fn addr_key(addr: &Address) -> Vec<G> {
 fn packed_digest_key(addr: &Address) -> Vec<G> {
   addr
     .as_bytes()
-    .chunks_exact(4)
+    .as_chunks::<4>()
+    .0
+    .iter()
     .map(|w| {
       G::from_u32(
         u32::from(w[0])
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index 051a10e1a..9e4899a3f 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -16,8 +16,8 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};
 use aiur::G;
 use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 };
 
-const INPUT_SIZE_0: usize = 3;
-const IN_0: usize = 3;
+const INPUT_SIZE_0: usize = 2;
+const IN_0: usize = 2;
 const OUT_0: usize = 1;
 fn aiur_fn_0(
   inp: [G; IN_0],
@@ -26,6 +26,422 @@ fn aiur_fn_0(
   unconstrained: bool,
 ) -> Result<[G; OUT_0], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 };
+    let __ret: [G; OUT_0] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[0].weight(); } record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_1: usize = 2;
+const IN_1: usize = 2;
+const OUT_1: usize = 1;
+fn aiur_fn_1(
+  inp: [G; IN_1],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_1], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = G::from_u64(256);
+    let __v_67: G = (__v_9 * __v_66);
+    let __v_68: G = (__v_67 + __v_8);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_70 + __v_7);
+    let __v_72: G = G::from_u64(256);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_73 + __v_6);
+    let __v_75: G = G::from_u64(256);
+    let __v_76: G = (__v_74 * __v_75);
+    let __v_77: G = (__v_76 + __v_5);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_77 * __v_78);
+    let __v_80: G = (__v_79 + __v_4);
+    let __v_81: G = G::from_u64(256);
+    let __v_82: G = (__v_80 * __v_81);
+    let __v_83: G = (__v_82 + __v_3);
+    let __v_84: G = G::from_u64(256);
+    let __v_85: G = (__v_41 * __v_84);
+    let __v_86: G = (__v_85 + __v_40);
+    let __v_87: G = G::from_u64(256);
+    let __v_88: G = (__v_86 * __v_87);
+    let __v_89: G = (__v_88 + __v_39);
+    let __v_90: G = G::from_u64(256);
+    let __v_91: G = (__v_89 * __v_90);
+    let __v_92: G = (__v_91 + __v_38);
+    let __v_93: G = G::from_u64(256);
+    let __v_94: G = (__v_92 * __v_93);
+    let __v_95: G = (__v_94 + __v_37);
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_95 * __v_96);
+    let __v_98: G = (__v_97 + __v_36);
+    let __v_99: G = G::from_u64(256);
+    let __v_100: G = (__v_98 * __v_99);
+    let __v_101: G = (__v_100 + __v_35);
+    let __v_102: G = (__v_83 - __v_101);
+    match __v_102.as_canonical_u64() {
+      0u64 => {
+        let __v_103: G = G::from_u64(256);
+        let __v_104: G = (__v_16 * __v_103);
+        let __v_105: G = (__v_104 + __v_15);
+        let __v_106: G = G::from_u64(256);
+        let __v_107: G = (__v_105 * __v_106);
+        let __v_108: G = (__v_107 + __v_14);
+        let __v_109: G = G::from_u64(256);
+        let __v_110: G = (__v_108 * __v_109);
+        let __v_111: G = (__v_110 + __v_13);
+        let __v_112: G = G::from_u64(256);
+        let __v_113: G = (__v_111 * __v_112);
+        let __v_114: G = (__v_113 + __v_12);
+        let __v_115: G = G::from_u64(256);
+        let __v_116: G = (__v_114 * __v_115);
+        let __v_117: G = (__v_116 + __v_11);
+        let __v_118: G = G::from_u64(256);
+        let __v_119: G = (__v_117 * __v_118);
+        let __v_120: G = (__v_119 + __v_10);
+        let __v_121: G = G::from_u64(256);
+        let __v_122: G = (__v_48 * __v_121);
+        let __v_123: G = (__v_122 + __v_47);
+        let __v_124: G = G::from_u64(256);
+        let __v_125: G = (__v_123 * __v_124);
+        let __v_126: G = (__v_125 + __v_46);
+        let __v_127: G = G::from_u64(256);
+        let __v_128: G = (__v_126 * __v_127);
+        let __v_129: G = (__v_128 + __v_45);
+        let __v_130: G = G::from_u64(256);
+        let __v_131: G = (__v_129 * __v_130);
+        let __v_132: G = (__v_131 + __v_44);
+        let __v_133: G = G::from_u64(256);
+        let __v_134: G = (__v_132 * __v_133);
+        let __v_135: G = (__v_134 + __v_43);
+        let __v_136: G = G::from_u64(256);
+        let __v_137: G = (__v_135 * __v_136);
+        let __v_138: G = (__v_137 + __v_42);
+        let __v_139: G = (__v_120 - __v_138);
+        match __v_139.as_canonical_u64() {
+          0u64 => {
+            let __v_140: G = G::from_u64(256);
+            let __v_141: G = (__v_23 * __v_140);
+            let __v_142: G = (__v_141 + __v_22);
+            let __v_143: G = G::from_u64(256);
+            let __v_144: G = (__v_142 * __v_143);
+            let __v_145: G = (__v_144 + __v_21);
+            let __v_146: G = G::from_u64(256);
+            let __v_147: G = (__v_145 * __v_146);
+            let __v_148: G = (__v_147 + __v_20);
+            let __v_149: G = G::from_u64(256);
+            let __v_150: G = (__v_148 * __v_149);
+            let __v_151: G = (__v_150 + __v_19);
+            let __v_152: G = G::from_u64(256);
+            let __v_153: G = (__v_151 * __v_152);
+            let __v_154: G = (__v_153 + __v_18);
+            let __v_155: G = G::from_u64(256);
+            let __v_156: G = (__v_154 * __v_155);
+            let __v_157: G = (__v_156 + __v_17);
+            let __v_158: G = G::from_u64(256);
+            let __v_159: G = (__v_55 * __v_158);
+            let __v_160: G = (__v_159 + __v_54);
+            let __v_161: G = G::from_u64(256);
+            let __v_162: G = (__v_160 * __v_161);
+            let __v_163: G = (__v_162 + __v_53);
+            let __v_164: G = G::from_u64(256);
+            let __v_165: G = (__v_163 * __v_164);
+            let __v_166: G = (__v_165 + __v_52);
+            let __v_167: G = G::from_u64(256);
+            let __v_168: G = (__v_166 * __v_167);
+            let __v_169: G = (__v_168 + __v_51);
+            let __v_170: G = G::from_u64(256);
+            let __v_171: G = (__v_169 * __v_170);
+            let __v_172: G = (__v_171 + __v_50);
+            let __v_173: G = G::from_u64(256);
+            let __v_174: G = (__v_172 * __v_173);
+            let __v_175: G = (__v_174 + __v_49);
+            let __v_176: G = (__v_157 - __v_175);
+            match __v_176.as_canonical_u64() {
+              0u64 => {
+                let __v_177: G = G::from_u64(256);
+                let __v_178: G = (__v_30 * __v_177);
+                let __v_179: G = (__v_178 + __v_29);
+                let __v_180: G = G::from_u64(256);
+                let __v_181: G = (__v_179 * __v_180);
+                let __v_182: G = (__v_181 + __v_28);
+                let __v_183: G = G::from_u64(256);
+                let __v_184: G = (__v_182 * __v_183);
+                let __v_185: G = (__v_184 + __v_27);
+                let __v_186: G = G::from_u64(256);
+                let __v_187: G = (__v_185 * __v_186);
+                let __v_188: G = (__v_187 + __v_26);
+                let __v_189: G = G::from_u64(256);
+                let __v_190: G = (__v_188 * __v_189);
+                let __v_191: G = (__v_190 + __v_25);
+                let __v_192: G = G::from_u64(256);
+                let __v_193: G = (__v_191 * __v_192);
+                let __v_194: G = (__v_193 + __v_24);
+                let __v_195: G = G::from_u64(256);
+                let __v_196: G = (__v_62 * __v_195);
+                let __v_197: G = (__v_196 + __v_61);
+                let __v_198: G = G::from_u64(256);
+                let __v_199: G = (__v_197 * __v_198);
+                let __v_200: G = (__v_199 + __v_60);
+                let __v_201: G = G::from_u64(256);
+                let __v_202: G = (__v_200 * __v_201);
+                let __v_203: G = (__v_202 + __v_59);
+                let __v_204: G = G::from_u64(256);
+                let __v_205: G = (__v_203 * __v_204);
+                let __v_206: G = (__v_205 + __v_58);
+                let __v_207: G = G::from_u64(256);
+                let __v_208: G = (__v_206 * __v_207);
+                let __v_209: G = (__v_208 + __v_57);
+                let __v_210: G = G::from_u64(256);
+                let __v_211: G = (__v_209 * __v_210);
+                let __v_212: G = (__v_211 + __v_56);
+                let __v_213: G = (__v_194 - __v_212);
+                match __v_213.as_canonical_u64() {
+                  0u64 => {
+                    let __v_214: G = G::from_u64(256);
+                    let __v_215: G = (__v_33 * __v_214);
+                    let __v_216: G = (__v_215 + __v_32);
+                    let __v_217: G = G::from_u64(256);
+                    let __v_218: G = (__v_216 * __v_217);
+                    let __v_219: G = (__v_218 + __v_31);
+                    let __v_220: G = G::from_u64(256);
+                    let __v_221: G = (__v_65 * __v_220);
+                    let __v_222: G = (__v_221 + __v_64);
+                    let __v_223: G = G::from_u64(256);
+                    let __v_224: G = (__v_222 * __v_223);
+                    let __v_225: G = (__v_224 + __v_63);
+                    let __v_226: G = (__v_219 - __v_225);
+                    match __v_226.as_canonical_u64() {
+                      0u64 => {
+                        let __v_227: G = G::from_u64(1);
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_227: G = G::from_u64(0);
+                        let __ret: [G; OUT_1] = [__v_227];
+                        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_214: G = G::from_u64(0);
+                    let __ret: [G; OUT_1] = [__v_214];
+                    if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                let __v_177: G = G::from_u64(0);
+                let __ret: [G; OUT_1] = [__v_177];
+                if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            let __v_140: G = G::from_u64(0);
+            let __ret: [G; OUT_1] = [__v_140];
+            if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        let __v_103: G = G::from_u64(0);
+        let __ret: [G; OUT_1] = [__v_103];
+        if !unconstrained { record.virt += record.function_queries[1].weight(); } record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_2: usize = 2;
+const IN_2: usize = 2;
+const OUT_2: usize = 1;
+fn aiur_fn_2(
+  inp: [G; IN_2],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_2], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = (__v_2 - __v_34);
+    match __v_66.as_canonical_u64() {
+      0u64 => {
+        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[1].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __v_67: G = __r_arr[0];
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_67: G = G::from_u64(0);
+        let __ret: [G; OUT_2] = [__v_67];
+        if !unconstrained { record.virt += record.function_queries[2].weight(); } record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_3: usize = 3;
+const IN_3: usize = 3;
+const OUT_3: usize = 1;
+fn aiur_fn_3(
+  inp: [G; IN_3],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_3], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -33,9 +449,9 @@ fn aiur_fn_0(
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_5];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -43,30 +459,31 @@ fn aiur_fn_0(
         let __v_4: G = (__v_1 + __v_3);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 - __v_5);
-        let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[3].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
         let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
         let __v_8: G = __io_read[0];
         let __v_9: G = G::from_u64(0);
-        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_0] = [__v_10];
-        if let Some(result) = record.function_queries[0].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_3] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[3].weight(); } record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_1: usize = 8;
-const IN_1: usize = 8;
-const OUT_1: usize = 1;
-fn aiur_fn_1(
-  inp: [G; IN_1],
+const INPUT_SIZE_4: usize = 8;
+const IN_4: usize = 8;
+const OUT_4: usize = 1;
+fn aiur_fn_4(
+  inp: [G; IN_4],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_1], ExecError> {
+) -> Result<[G; OUT_4], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -92,86 +509,87 @@ fn aiur_fn_1(
                                 match __v_7.as_canonical_u64() {
                                   0u64 => {
                                     let __v_8: G = G::from_u64(1);
-                                    let __ret: [G; OUT_1] = [__v_8];
-                                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_8: G = G::from_u64(0);
-                                    let __ret: [G; OUT_1] = [__v_8];
-                                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_4] = [__v_8];
+                                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
                                 let __v_8: G = G::from_u64(0);
-                                let __ret: [G; OUT_1] = [__v_8];
-                                if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_4] = [__v_8];
+                                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_8: G = G::from_u64(0);
-                            let __ret: [G; OUT_1] = [__v_8];
-                            if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_4] = [__v_8];
+                            if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_8: G = G::from_u64(0);
-                        let __ret: [G; OUT_1] = [__v_8];
-                        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_4] = [__v_8];
+                        if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_8: G = G::from_u64(0);
-                    let __ret: [G; OUT_1] = [__v_8];
-                    if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_4] = [__v_8];
+                    if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_8: G = G::from_u64(0);
-                let __ret: [G; OUT_1] = [__v_8];
-                if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_4] = [__v_8];
+                if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_1] = [__v_8];
-            if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_4] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_1] = [__v_8];
-        if let Some(result) = record.function_queries[1].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_4] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[4].weight(); } record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_2: usize = 8;
-const IN_2: usize = 8;
-const OUT_2: usize = 4;
-fn aiur_fn_2(
-  inp: [G; IN_2],
+const INPUT_SIZE_5: usize = 8;
+const IN_5: usize = 8;
+const OUT_5: usize = 4;
+fn aiur_fn_5(
+  inp: [G; IN_5],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_2], ExecError> {
+) -> Result<[G; OUT_5], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -193,22 +611,23 @@ fn aiur_fn_2(
     if (__v_13 != __v_12) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) });
     }
-    let __ret: [G; OUT_2] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[2].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[2].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[5].weight(); } record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_3: usize = 12;
-const IN_3: usize = 12;
-const OUT_3: usize = 4;
-fn aiur_fn_3(
-  inp: [G; IN_3],
+const INPUT_SIZE_6: usize = 12;
+const IN_6: usize = 12;
+const OUT_6: usize = 4;
+fn aiur_fn_6(
+  inp: [G; IN_6],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_3], ExecError> {
+) -> Result<[G; OUT_6], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -240,22 +659,23 @@ fn aiur_fn_3(
     if (__v_22 != __v_23) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) });
     }
-    let __ret: [G; OUT_3] = [__v_12, __v_13, __v_14, __v_15];
-    if let Some(result) = record.function_queries[3].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[3].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[6].weight(); } record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_4: usize = 8;
-const IN_4: usize = 8;
-const OUT_4: usize = 4;
-fn aiur_fn_4(
-  inp: [G; IN_4],
+const INPUT_SIZE_7: usize = 8;
+const IN_7: usize = 8;
+const OUT_7: usize = 4;
+fn aiur_fn_7(
+  inp: [G; IN_7],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_4], ExecError> {
+) -> Result<[G; OUT_7], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -268,62 +688,65 @@ fn aiur_fn_4(
     let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) };
     let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) };
     let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) };
-    let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11];
-    if let Some(result) = record.function_queries[4].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[4].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11];
+    if !unconstrained { record.virt += record.function_queries[7].weight(); } record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_5: usize = 4;
-const IN_5: usize = 4;
-const OUT_5: usize = 4;
-fn aiur_fn_5(
-  inp: [G; IN_5],
+const INPUT_SIZE_8: usize = 4;
+const IN_8: usize = 4;
+const OUT_8: usize = 4;
+fn aiur_fn_8(
+  inp: [G; IN_8],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_5], ExecError> {
+) -> Result<[G; OUT_8], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_5] = [__v_2, __v_3, __v_0, __v_1];
-    if let Some(result) = record.function_queries[5].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1];
+    if !unconstrained { record.virt += record.function_queries[8].weight(); } record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_6: usize = 4;
-const IN_6: usize = 4;
-const OUT_6: usize = 4;
-fn aiur_fn_6(
-  inp: [G; IN_6],
+const INPUT_SIZE_9: usize = 4;
+const IN_9: usize = 4;
+const OUT_9: usize = 4;
+fn aiur_fn_9(
+  inp: [G; IN_9],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_6], ExecError> {
+) -> Result<[G; OUT_9], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __ret: [G; OUT_6] = [__v_1, __v_2, __v_3, __v_0];
-    if let Some(result) = record.function_queries[6].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0];
+    if !unconstrained { record.virt += record.function_queries[9].weight(); } record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_7: usize = 8;
-const IN_7: usize = 8;
-const OUT_7: usize = 4;
-fn aiur_fn_7(
-  inp: [G; IN_7],
+const INPUT_SIZE_10: usize = 8;
+const IN_10: usize = 8;
+const OUT_10: usize = 4;
+fn aiur_fn_10(
+  inp: [G; IN_10],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_7], ExecError> {
+) -> Result<[G; OUT_10], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -348,22 +771,23 @@ fn aiur_fn_7(
     let __v_17: G = (__v_10 + __v_13);
     let __v_18: G = (__v_12 + __v_15);
     let __v_19: G = (__v_14 + __v_9);
-    let __ret: [G; OUT_7] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[7].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[10].weight(); } record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_8: usize = 8;
-const IN_8: usize = 8;
-const OUT_8: usize = 4;
-fn aiur_fn_8(
-  inp: [G; IN_8],
+const INPUT_SIZE_11: usize = 8;
+const IN_11: usize = 8;
+const OUT_11: usize = 4;
+fn aiur_fn_11(
+  inp: [G; IN_11],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_8], ExecError> {
+) -> Result<[G; OUT_11], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -388,22 +812,23 @@ fn aiur_fn_8(
     let __v_17: G = (__v_12 + __v_15);
     let __v_18: G = (__v_14 + __v_9);
     let __v_19: G = (__v_8 + __v_11);
-    let __ret: [G; OUT_8] = [__v_16, __v_17, __v_18, __v_19];
-    if let Some(result) = record.function_queries[8].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19];
+    if !unconstrained { record.virt += record.function_queries[11].weight(); } record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_9: usize = 8;
-const IN_9: usize = 8;
-const OUT_9: usize = 8;
-fn aiur_fn_9(
-  inp: [G; IN_9],
+const INPUT_SIZE_12: usize = 8;
+const IN_12: usize = 8;
+const OUT_12: usize = 8;
+fn aiur_fn_12(
+  inp: [G; IN_12],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_9], ExecError> {
+) -> Result<[G; OUT_12], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -436,8 +861,8 @@ fn aiur_fn_9(
                                     let __v_13: G = G::from_u64(0);
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(0);
-                                    let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-                                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+                                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -450,8 +875,8 @@ fn aiur_fn_9(
                                     let __v_14: G = G::from_u64(0);
                                     let __v_15: G = G::from_u64(1);
                                     let __v_16: G = (__v_7 + __v_15);
-                                    let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
-                                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16];
+                                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
@@ -465,8 +890,8 @@ fn aiur_fn_9(
                                 let __v_13: G = G::from_u64(0);
                                 let __v_14: G = G::from_u64(1);
                                 let __v_15: G = (__v_6 + __v_14);
-                                let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
-                                if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7];
+                                if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
@@ -479,8 +904,8 @@ fn aiur_fn_9(
                             let __v_12: G = G::from_u64(0);
                             let __v_13: G = G::from_u64(1);
                             let __v_14: G = (__v_5 + __v_13);
-                            let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
-                            if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7];
+                            if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
@@ -492,8 +917,8 @@ fn aiur_fn_9(
                         let __v_11: G = G::from_u64(0);
                         let __v_12: G = G::from_u64(1);
                         let __v_13: G = (__v_4 + __v_12);
-                        let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
-                        if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7];
+                        if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
@@ -504,8 +929,8 @@ fn aiur_fn_9(
                     let __v_10: G = G::from_u64(0);
                     let __v_11: G = G::from_u64(1);
                     let __v_12: G = (__v_3 + __v_11);
-                    let __ret: [G; OUT_9] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
-                    if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7];
+                    if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -515,8 +940,8 @@ fn aiur_fn_9(
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(1);
                 let __v_11: G = (__v_2 + __v_10);
-                let __ret: [G; OUT_9] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
-                if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_12] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7];
+                if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -525,8 +950,8 @@ fn aiur_fn_9(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_1 + __v_9);
-            let __ret: [G; OUT_9] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-            if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_12] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -534,24 +959,25 @@ fn aiur_fn_9(
       _ => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_0 + __v_8);
-        let __ret: [G; OUT_9] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[9].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_12] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[12].weight(); } record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_10: usize = 8;
-const IN_10: usize = 8;
-const OUT_10: usize = 1;
-fn aiur_fn_10(
-  inp: [G; IN_10],
+const INPUT_SIZE_13: usize = 8;
+const IN_13: usize = 8;
+const OUT_13: usize = 1;
+fn aiur_fn_13(
+  inp: [G; IN_13],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_10], ExecError> {
+) -> Result<[G; OUT_13], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -582,22 +1008,23 @@ fn aiur_fn_10(
     let __v_24: G = (__v_12 + __v_23);
     let __v_25: G = (__v_10 + __v_24);
     let __v_26: G = (__v_0 + __v_25);
-    let __ret: [G; OUT_10] = [__v_26];
-    if let Some(result) = record.function_queries[10].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_13] = [__v_26];
+    if !unconstrained { record.virt += record.function_queries[13].weight(); } record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_11: usize = 8;
-const IN_11: usize = 8;
-const OUT_11: usize = 1;
-fn aiur_fn_11(
-  inp: [G; IN_11],
+const INPUT_SIZE_14: usize = 8;
+const IN_14: usize = 8;
+const OUT_14: usize = 1;
+fn aiur_fn_14(
+  inp: [G; IN_14],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_11], ExecError> {
+) -> Result<[G; OUT_14], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -627,22 +1054,23 @@ fn aiur_fn_11(
     let __v_26: G = (__v_11 + __v_25);
     let __v_27: G = (__v_9 + __v_26);
     let __v_28: G = (__v_0 + __v_27);
-    let __ret: [G; OUT_11] = [__v_28];
-    if let Some(result) = record.function_queries[11].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[11].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_14] = [__v_28];
+    if !unconstrained { record.virt += record.function_queries[14].weight(); } record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_12: usize = 8;
-const IN_12: usize = 8;
-const OUT_12: usize = 1;
-fn aiur_fn_12(
-  inp: [G; IN_12],
+const INPUT_SIZE_15: usize = 8;
+const IN_15: usize = 8;
+const OUT_15: usize = 1;
+fn aiur_fn_15(
+  inp: [G; IN_15],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_12], ExecError> {
+) -> Result<[G; OUT_15], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -666,22 +1094,23 @@ fn aiur_fn_12(
     let __v_20: G = (__v_19 - __v_17);
     let __v_21: G = (__v_13 * __v_20);
     let __v_22: G = (__v_18 - __v_21);
-    let __ret: [G; OUT_12] = [__v_22];
-    if let Some(result) = record.function_queries[12].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_15] = [__v_22];
+    if !unconstrained { record.virt += record.function_queries[15].weight(); } record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_13: usize = 1;
-const IN_13: usize = 1;
-const OUT_13: usize = 8;
-fn aiur_fn_13(
-  inp: [G; IN_13],
+const INPUT_SIZE_16: usize = 1;
+const IN_16: usize = 1;
+const OUT_16: usize = 8;
+fn aiur_fn_16(
+  inp: [G; IN_16],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_13], ExecError> {
+) -> Result<[G; OUT_16], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
     let __v_1: G = G::from_u8(__gb[0]);
@@ -739,22 +1168,23 @@ fn aiur_fn_13(
     if (__v_44 != __v_45) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    if let Some(result) = record.function_queries[13].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[16].weight(); } record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_14: usize = 1;
-const IN_14: usize = 1;
-const OUT_14: usize = 1;
-fn aiur_fn_14(
-  inp: [G; IN_14],
+const INPUT_SIZE_17: usize = 1;
+const IN_17: usize = 1;
+const OUT_17: usize = 1;
+fn aiur_fn_17(
+  inp: [G; IN_17],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_14], ExecError> {
+) -> Result<[G; OUT_17], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = g_inverse_value(__v_0);
     let __v_2: G = (__v_0 * __v_1);
@@ -770,88 +1200,92 @@ fn aiur_fn_14(
     if (__v_7 != __v_8) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_14] = [__v_1];
-    if let Some(result) = record.function_queries[14].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_17] = [__v_1];
+    if !unconstrained { record.virt += record.function_queries[17].weight(); } record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_15: usize = 4;
-const IN_15: usize = 4;
-const OUT_15: usize = 2;
-fn aiur_fn_15(
-  inp: [G; IN_15],
+const INPUT_SIZE_18: usize = 4;
+const IN_18: usize = 4;
+const OUT_18: usize = 2;
+fn aiur_fn_18(
+  inp: [G; IN_18],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_15], ExecError> {
+) -> Result<[G; OUT_18], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 + __v_2);
     let __v_5: G = (__v_1 + __v_3);
-    let __ret: [G; OUT_15] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[15].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_18] = [__v_4, __v_5];
+    if !unconstrained { record.virt += record.function_queries[18].weight(); } record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_16: usize = 4;
-const IN_16: usize = 4;
-const OUT_16: usize = 2;
-fn aiur_fn_16(
-  inp: [G; IN_16],
+const INPUT_SIZE_19: usize = 4;
+const IN_19: usize = 4;
+const OUT_19: usize = 2;
+fn aiur_fn_19(
+  inp: [G; IN_19],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_16], ExecError> {
+) -> Result<[G; OUT_19], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = (__v_0 - __v_2);
     let __v_5: G = (__v_1 - __v_3);
-    let __ret: [G; OUT_16] = [__v_4, __v_5];
-    if let Some(result) = record.function_queries[16].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_19] = [__v_4, __v_5];
+    if !unconstrained { record.virt += record.function_queries[19].weight(); } record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_17: usize = 2;
-const IN_17: usize = 2;
-const OUT_17: usize = 2;
-fn aiur_fn_17(
-  inp: [G; IN_17],
+const INPUT_SIZE_20: usize = 2;
+const IN_20: usize = 2;
+const OUT_20: usize = 2;
+fn aiur_fn_20(
+  inp: [G; IN_20],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_17], ExecError> {
+) -> Result<[G; OUT_20], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
     let __v_3: G = (__v_2 - __v_0);
     let __v_4: G = G::from_u64(0);
     let __v_5: G = (__v_4 - __v_1);
-    let __ret: [G; OUT_17] = [__v_3, __v_5];
-    if let Some(result) = record.function_queries[17].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_20] = [__v_3, __v_5];
+    if !unconstrained { record.virt += record.function_queries[20].weight(); } record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_18: usize = 4;
-const IN_18: usize = 4;
-const OUT_18: usize = 2;
-fn aiur_fn_18(
-  inp: [G; IN_18],
+const INPUT_SIZE_21: usize = 4;
+const IN_21: usize = 4;
+const OUT_21: usize = 2;
+fn aiur_fn_21(
+  inp: [G; IN_21],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_18], ExecError> {
+) -> Result<[G; OUT_21], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -864,22 +1298,23 @@ fn aiur_fn_18(
     let __v_9: G = (__v_0 * __v_3);
     let __v_10: G = (__v_1 * __v_2);
     let __v_11: G = (__v_9 + __v_10);
-    let __ret: [G; OUT_18] = [__v_8, __v_11];
-    if let Some(result) = record.function_queries[18].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_21] = [__v_8, __v_11];
+    if !unconstrained { record.virt += record.function_queries[21].weight(); } record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_19: usize = 2;
-const IN_19: usize = 2;
-const OUT_19: usize = 2;
-fn aiur_fn_19(
-  inp: [G; IN_19],
+const INPUT_SIZE_22: usize = 2;
+const IN_22: usize = 2;
+const OUT_22: usize = 2;
+fn aiur_fn_22(
+  inp: [G; IN_22],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_19], ExecError> {
+) -> Result<[G; OUT_22], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = (__v_0 * __v_0);
@@ -905,22 +1340,23 @@ fn aiur_fn_19(
     let __v_16: G = G::from_u64(0);
     let __v_17: G = (__v_16 - __v_1);
     let __v_18: G = (__v_17 * __v_7);
-    let __ret: [G; OUT_19] = [__v_15, __v_18];
-    if let Some(result) = record.function_queries[19].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_22] = [__v_15, __v_18];
+    if !unconstrained { record.virt += record.function_queries[22].weight(); } record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_20: usize = 4;
-const IN_20: usize = 4;
-const OUT_20: usize = 2;
-fn aiur_fn_20(
-  inp: [G; IN_20],
+const INPUT_SIZE_23: usize = 4;
+const IN_23: usize = 4;
+const OUT_23: usize = 2;
+fn aiur_fn_23(
+  inp: [G; IN_23],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_20], ExecError> {
+) -> Result<[G; OUT_23], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -956,22 +1392,23 @@ fn aiur_fn_20(
     let __v_26: G = (__v_0 * __v_20);
     let __v_27: G = (__v_1 * __v_17);
     let __v_28: G = (__v_26 + __v_27);
-    let __ret: [G; OUT_20] = [__v_25, __v_28];
-    if let Some(result) = record.function_queries[20].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_23] = [__v_25, __v_28];
+    if !unconstrained { record.virt += record.function_queries[23].weight(); } record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_21: usize = 4;
-const IN_21: usize = 4;
-const OUT_21: usize = 1;
-fn aiur_fn_21(
-  inp: [G; IN_21],
+const INPUT_SIZE_24: usize = 4;
+const IN_24: usize = 4;
+const OUT_24: usize = 1;
+fn aiur_fn_24(
+  inp: [G; IN_24],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_21], ExecError> {
+) -> Result<[G; OUT_24], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -981,40 +1418,41 @@ fn aiur_fn_21(
     let __v_6: G = (__v_1 - __v_3);
     let __v_7: G = G::from_bool((__v_6 == G::ZERO));
     let __v_8: G = (__v_5 * __v_7);
-    let __ret: [G; OUT_21] = [__v_8];
-    if let Some(result) = record.function_queries[21].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_24] = [__v_8];
+    if !unconstrained { record.virt += record.function_queries[24].weight(); } record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_22: usize = 1;
-const IN_22: usize = 1;
-const OUT_22: usize = 2;
-fn aiur_fn_22(
-  inp: [G; IN_22],
+const INPUT_SIZE_25: usize = 1;
+const IN_25: usize = 1;
+const OUT_25: usize = 2;
+fn aiur_fn_25(
+  inp: [G; IN_25],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_22], ExecError> {
+) -> Result<[G; OUT_25], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __ret: [G; OUT_22] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_25] = [__v_2, __v_3];
+        if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_22] = [__v_4, __v_7];
-        if let Some(result) = record.function_queries[22].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_25] = [__v_4, __v_7];
+        if !unconstrained { record.virt += record.function_queries[25].weight(); } record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -1024,59 +1462,61 @@ fn aiur_fn_22(
   })
 }
 
-const INPUT_SIZE_23: usize = 1;
-const IN_23: usize = 1;
-const OUT_23: usize = 9;
-fn aiur_fn_23(
-  inp: [G; IN_23],
+const INPUT_SIZE_26: usize = 1;
+const IN_26: usize = 1;
+const OUT_26: usize = 9;
+fn aiur_fn_26(
+  inp: [G; IN_26],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_23], ExecError> {
+) -> Result<[G; OUT_26], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_22(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_22] = unsafe { *(result.output.as_ptr() as *const [G; OUT_22]) }; __ret } } else { aiur_fn_22(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __ret: [G; OUT_23] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
-    if let Some(result) = record.function_queries[23].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_26] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if !unconstrained { record.virt += record.function_queries[26].weight(); } record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_24: usize = 1;
-const IN_24: usize = 1;
-const OUT_24: usize = 2;
-fn aiur_fn_24(
-  inp: [G; IN_24],
+const INPUT_SIZE_27: usize = 1;
+const IN_27: usize = 1;
+const OUT_27: usize = 2;
+fn aiur_fn_27(
+  inp: [G; IN_27],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_24], ExecError> {
+) -> Result<[G; OUT_27], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__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];
@@ -1086,46 +1526,48 @@ fn aiur_fn_24(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_24] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[24].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_27] = [__v_10, __v_9];
+    if !unconstrained { record.virt += record.function_queries[27].weight(); } record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_25: usize = 1;
-const IN_25: usize = 1;
-const OUT_25: usize = 2;
-fn aiur_fn_25(
-  inp: [G; IN_25],
+const INPUT_SIZE_28: usize = 1;
+const IN_28: usize = 1;
+const OUT_28: usize = 2;
+fn aiur_fn_28(
+  inp: [G; IN_28],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_25], ExecError> {
+) -> Result<[G; OUT_28], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr };
     let __v_2: G = __io_read[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_0 + __v_3);
-    let __ret: [G; OUT_25] = [__v_2, __v_4];
-    if let Some(result) = record.function_queries[25].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_28] = [__v_2, __v_4];
+    if !unconstrained { record.virt += record.function_queries[28].weight(); } record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_26: usize = 1;
-const IN_26: usize = 1;
-const OUT_26: usize = 9;
-fn aiur_fn_26(
-  inp: [G; IN_26],
+const INPUT_SIZE_29: usize = 1;
+const IN_29: usize = 1;
+const OUT_29: usize = 9;
+fn aiur_fn_29(
+  inp: [G; IN_29],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_26], ExecError> {
+) -> Result<[G; OUT_29], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
     let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr };
@@ -1139,24 +1581,25 @@ fn aiur_fn_26(
     let __v_9: G = __io_read[7];
     let __v_10: G = G::from_u64(8);
     let __v_11: G = (__v_0 + __v_10);
-    let __ret: [G; OUT_26] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
-    if let Some(result) = record.function_queries[26].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11];
+    if !unconstrained { record.virt += record.function_queries[29].weight(); } record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_27: usize = 1;
-const IN_27: usize = 1;
-const OUT_27: usize = 2;
-fn aiur_fn_27(
-  inp: [G; IN_27],
+const INPUT_SIZE_30: usize = 1;
+const IN_30: usize = 1;
+const OUT_30: usize = 2;
+fn aiur_fn_30(
+  inp: [G; IN_30],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_27], ExecError> {
+) -> Result<[G; OUT_30], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1166,26 +1609,27 @@ fn aiur_fn_27(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_10(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } } else { aiur_fn_10(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-    let __ret: [G; OUT_27] = [__v_10, __v_9];
-    if let Some(result) = record.function_queries[27].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_30] = [__v_10, __v_9];
+    if !unconstrained { record.virt += record.function_queries[30].weight(); } record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_28: usize = 1;
-const IN_28: usize = 1;
-const OUT_28: usize = 3;
-fn aiur_fn_28(
-  inp: [G; IN_28],
+const INPUT_SIZE_31: usize = 1;
+const IN_31: usize = 1;
+const OUT_31: usize = 3;
+fn aiur_fn_31(
+  inp: [G; IN_31],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_28], ExecError> {
+) -> Result<[G; OUT_31], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1195,7 +1639,7 @@ fn aiur_fn_28(
     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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1247,24 +1691,25 @@ fn aiur_fn_28(
     let __v_58: G = (__v_43 + __v_57);
     let __v_59: G = (__v_41 + __v_58);
     let __v_60: G = (__v_10 + __v_59);
-    let __ret: [G; OUT_28] = [__v_39, __v_60, __v_18];
-    if let Some(result) = record.function_queries[28].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_31] = [__v_39, __v_60, __v_18];
+    if !unconstrained { record.virt += record.function_queries[31].weight(); } record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_29: usize = 1;
-const IN_29: usize = 1;
-const OUT_29: usize = 33;
-fn aiur_fn_29(
-  inp: [G; IN_29],
+const INPUT_SIZE_32: usize = 1;
+const IN_32: usize = 1;
+const OUT_32: usize = 33;
+fn aiur_fn_32(
+  inp: [G; IN_32],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_29], ExecError> {
+) -> Result<[G; OUT_32], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1274,7 +1719,7 @@ fn aiur_fn_29(
     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_26] = { let __args: [G; IN_26] = [__v_9]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1284,7 +1729,7 @@ fn aiur_fn_29(
     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_26] = { let __args: [G; IN_26] = [__v_18]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1294,7 +1739,7 @@ fn aiur_fn_29(
     let __v_25: G = __r_arr[6];
     let __v_26: G = __r_arr[7];
     let __v_27: G = __r_arr[8];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_27]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1304,121 +1749,125 @@ fn aiur_fn_29(
     let __v_34: G = __r_arr[6];
     let __v_35: G = __r_arr[7];
     let __v_36: G = __r_arr[8];
-    let __ret: [G; OUT_29] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-    if let Some(result) = record.function_queries[29].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if !unconstrained { record.virt += record.function_queries[32].weight(); } record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_30: usize = 1;
-const IN_30: usize = 1;
-const OUT_30: usize = 2;
-fn aiur_fn_30(
-  inp: [G; IN_30],
+const INPUT_SIZE_33: usize = 1;
+const IN_33: usize = 1;
+const OUT_33: usize = 2;
+fn aiur_fn_33(
+  inp: [G; IN_33],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_30], ExecError> {
+) -> Result<[G; OUT_33], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_30] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[30].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_33] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[33].weight(); } record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_31: usize = 2;
-const IN_31: usize = 2;
-const OUT_31: usize = 2;
-fn aiur_fn_31(
-  inp: [G; IN_31],
+const INPUT_SIZE_34: usize = 2;
+const IN_34: usize = 2;
+const OUT_34: usize = 2;
+fn aiur_fn_34(
+  inp: [G; IN_34],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_31], ExecError> {
+) -> Result<[G; OUT_34], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_34] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_31] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[31].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_34] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[34].weight(); } record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_32: usize = 1;
-const IN_32: usize = 1;
-const OUT_32: usize = 2;
-fn aiur_fn_32(
-  inp: [G; IN_32],
+const INPUT_SIZE_35: usize = 1;
+const IN_35: usize = 1;
+const OUT_35: usize = 2;
+fn aiur_fn_35(
+  inp: [G; IN_35],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_32], ExecError> {
+) -> Result<[G; OUT_35], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_32] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[32].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_35] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[35].weight(); } record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_33: usize = 2;
-const IN_33: usize = 2;
-const OUT_33: usize = 2;
-fn aiur_fn_33(
-  inp: [G; IN_33],
+const INPUT_SIZE_36: usize = 2;
+const IN_36: usize = 2;
+const OUT_36: usize = 2;
+fn aiur_fn_36(
+  inp: [G; IN_36],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_33], ExecError> {
+) -> Result<[G; OUT_36], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_36] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1430,65 +1879,67 @@ fn aiur_fn_33(
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[33].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_33(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } } else { aiur_fn_33(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; 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 { let __r = record.function_queries[36].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_33] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[33].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_36] = [__v_16, __v_14];
+        if !unconstrained { record.virt += record.function_queries[36].weight(); } record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_34: usize = 1;
-const IN_34: usize = 1;
-const OUT_34: usize = 2;
-fn aiur_fn_34(
-  inp: [G; IN_34],
+const INPUT_SIZE_37: usize = 1;
+const IN_37: usize = 1;
+const OUT_37: usize = 2;
+fn aiur_fn_37(
+  inp: [G; IN_37],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_34], ExecError> {
+) -> Result<[G; OUT_37], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_34] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[34].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_37] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[37].weight(); } record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_35: usize = 2;
-const IN_35: usize = 2;
-const OUT_35: usize = 2;
-fn aiur_fn_35(
-  inp: [G; IN_35],
+const INPUT_SIZE_38: usize = 2;
+const IN_38: usize = 2;
+const OUT_38: usize = 2;
+fn aiur_fn_38(
+  inp: [G; IN_38],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_35], ExecError> {
+) -> Result<[G; OUT_38], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_38] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1498,7 +1949,7 @@ fn aiur_fn_35(
         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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1552,65 +2003,67 @@ fn aiur_fn_35(
         let __v_61: G = (__v_11 + __v_60);
         let __v_62: G = G::from_u64(1);
         let __v_63: G = (__v_1 - __v_62);
-        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_19, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[35].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_35(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_35] = unsafe { *(result.output.as_ptr() as *const [G; OUT_35]) }; __ret } } else { aiur_fn_35(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; 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 { let __r = record.function_queries[38].replay_at(__i); record.virt += __r; } 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_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; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_35] = [__v_67, __v_65];
-        if let Some(result) = record.function_queries[35].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_38] = [__v_67, __v_65];
+        if !unconstrained { record.virt += record.function_queries[38].weight(); } record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_36: usize = 1;
-const IN_36: usize = 1;
-const OUT_36: usize = 2;
-fn aiur_fn_36(
-  inp: [G; IN_36],
+const INPUT_SIZE_39: usize = 1;
+const IN_39: usize = 1;
+const OUT_39: usize = 2;
+fn aiur_fn_39(
+  inp: [G; IN_39],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_36], ExecError> {
+) -> Result<[G; OUT_39], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; 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 { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_36] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[36].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_39] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[39].weight(); } record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_37: usize = 2;
-const IN_37: usize = 2;
-const OUT_37: usize = 2;
-fn aiur_fn_37(
-  inp: [G; IN_37],
+const INPUT_SIZE_40: usize = 2;
+const IN_40: usize = 2;
+const OUT_40: usize = 2;
+fn aiur_fn_40(
+  inp: [G; IN_40],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_37], ExecError> {
+) -> Result<[G; OUT_40], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_37] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_40] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1620,7 +2073,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_10]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1630,7 +2083,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_19]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_19]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1640,7 +2093,7 @@ fn aiur_fn_37(
         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_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__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];
@@ -1652,229 +2105,153 @@ fn aiur_fn_37(
         let __v_37: G = __r_arr[8];
         let __v_38: G = G::from_u64(1);
         let __v_39: G = (__v_1 - __v_38);
-        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_37(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_37] = unsafe { *(result.output.as_ptr() as *const [G; OUT_37]) }; __ret } } else { aiur_fn_37(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; 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 { let __r = record.function_queries[40].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
         let __v_41: G = __r_arr[1];
         let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_37] = [__v_44, __v_41];
-        if let Some(result) = record.function_queries[37].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_40] = [__v_44, __v_41];
+        if !unconstrained { record.virt += record.function_queries[40].weight(); } record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_38: usize = 1;
-const IN_38: usize = 1;
-const OUT_38: usize = 2;
-fn aiur_fn_38(
-  inp: [G; IN_38],
+const INPUT_SIZE_41: usize = 1;
+const IN_41: usize = 1;
+const OUT_41: usize = 2;
+fn aiur_fn_41(
+  inp: [G; IN_41],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_38], ExecError> {
+) -> Result<[G; OUT_41], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_38] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[38].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_41] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[41].weight(); } record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_39: usize = 2;
-const IN_39: usize = 2;
-const OUT_39: usize = 2;
-fn aiur_fn_39(
-  inp: [G; IN_39],
+const INPUT_SIZE_42: usize = 2;
+const IN_42: usize = 2;
+const OUT_42: usize = 2;
+fn aiur_fn_42(
+  inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_39], ExecError> {
+) -> Result<[G; OUT_42], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_39] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_42] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_39] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[39].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_42] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[42].weight(); } record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_40: usize = 1;
-const IN_40: usize = 1;
-const OUT_40: usize = 2;
-fn aiur_fn_40(
-  inp: [G; IN_40],
+const INPUT_SIZE_43: usize = 1;
+const IN_43: usize = 1;
+const OUT_43: usize = 2;
+fn aiur_fn_43(
+  inp: [G; IN_43],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_40], ExecError> {
+) -> Result<[G; OUT_43], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_40] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[40].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_43] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[43].weight(); } record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_41: usize = 2;
-const IN_41: usize = 2;
-const OUT_41: usize = 2;
-fn aiur_fn_41(
-  inp: [G; IN_41],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_41], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_41] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_41(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } } else { aiur_fn_41(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_41] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[41].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_42: usize = 1;
-const IN_42: usize = 1;
-const OUT_42: usize = 2;
-fn aiur_fn_42(
-  inp: [G; IN_42],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_42], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_42] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[42].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_43: usize = 2;
-const IN_43: usize = 2;
-const OUT_43: usize = 2;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_44: usize = 2;
+const IN_44: usize = 2;
+const OUT_44: usize = 2;
+fn aiur_fn_44(
+  inp: [G; IN_44],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], ExecError> {
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_43] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_44] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[40].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_40(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_40] = unsafe { *(result.output.as_ptr() as *const [G; OUT_40]) }; __ret } } else { aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[43].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_43(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_43] = unsafe { *(result.output.as_ptr() as *const [G; OUT_43]) }; __ret } } else { aiur_fn_43(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_43] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[43].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; 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 { let __r = record.function_queries[42].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_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_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_44] = [__v_11, __v_9];
+        if !unconstrained { record.virt += record.function_queries[44].weight(); } record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 1;
-const IN_44: usize = 1;
-const OUT_44: usize = 2;
-fn aiur_fn_44(
-  inp: [G; IN_44],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __ret: [G; OUT_44] = [__v_1, __v_2];
-    if let Some(result) = record.function_queries[44].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
 const INPUT_SIZE_45: usize = 1;
 const IN_45: usize = 1;
 const OUT_45: usize = 2;
@@ -1885,15 +2262,16 @@ fn aiur_fn_45(
   unconstrained: bool,
 ) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __ret: [G; OUT_45] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[45].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if !unconstrained { record.virt += record.function_queries[45].weight(); } record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
@@ -1908,30 +2286,31 @@ fn aiur_fn_46(
   unconstrained: bool,
 ) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_46] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __ret: [G; OUT_46] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[46].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[46].weight(); } record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
@@ -1940,7 +2319,7 @@ fn aiur_fn_46(
 
 const INPUT_SIZE_47: usize = 1;
 const IN_47: usize = 1;
-const OUT_47: usize = 4;
+const OUT_47: usize = 2;
 fn aiur_fn_47(
   inp: [G; IN_47],
   record: &mut QueryRecord,
@@ -1948,25 +2327,23 @@ fn aiur_fn_47(
   unconstrained: bool,
 ) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; 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 { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_47] = [__v_1, __v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[47].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_47] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[47].weight(); } record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_48: usize = 1;
-const IN_48: usize = 1;
-const OUT_48: usize = 3;
+const INPUT_SIZE_48: usize = 2;
+const IN_48: usize = 2;
+const OUT_48: usize = 2;
 fn aiur_fn_48(
   inp: [G; IN_48],
   record: &mut QueryRecord,
@@ -1974,19 +2351,34 @@ fn aiur_fn_48(
   unconstrained: bool,
 ) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_48] = [__v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[48].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_48] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; 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 { let __r = record.function_queries[45].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; 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 { let __r = record.function_queries[48].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_48] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[48].weight(); } record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
@@ -2000,21 +2392,19 @@ fn aiur_fn_49(
   unconstrained: bool,
 ) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_49] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[49].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_49] = [__v_1, __v_2];
+    if !unconstrained { record.virt += record.function_queries[49].weight(); } record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_50: usize = 2;
-const IN_50: usize = 2;
+const INPUT_SIZE_50: usize = 1;
+const IN_50: usize = 1;
 const OUT_50: usize = 2;
 fn aiur_fn_50(
   inp: [G; IN_50],
@@ -2023,410 +2413,478 @@ fn aiur_fn_50(
   unconstrained: bool,
 ) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_50] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[50].weight(); } record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_51: usize = 2;
+const IN_51: usize = 2;
+const OUT_51: usize = 2;
+fn aiur_fn_51(
+  inp: [G; IN_51],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_51], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_51] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[39].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_39(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_39] = unsafe { *(result.output.as_ptr() as *const [G; OUT_39]) }; __ret } } else { aiur_fn_39(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_1 - __v_4);
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; 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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_50] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[50].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_51] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[51].weight(); } record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_51: usize = 1;
-const IN_51: usize = 1;
-const OUT_51: usize = 4;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_52: usize = 1;
+const IN_52: usize = 1;
+const OUT_52: usize = 4;
+fn aiur_fn_52(
+  inp: [G; IN_52],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_51] = [__v_1, __v_3, __v_5, __v_6];
-    if let Some(result) = record.function_queries[51].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_52] = [__v_1, __v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[52].weight(); } record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_52: usize = 1;
-const IN_52: usize = 1;
-const OUT_52: usize = 2;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_53: usize = 1;
+const IN_53: usize = 1;
+const OUT_53: usize = 3;
+fn aiur_fn_53(
+  inp: [G; IN_53],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], ExecError> {
+) -> Result<[G; OUT_53], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_52] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[52].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __ret: [G; OUT_53] = [__v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[53].weight(); } record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_53: usize = 2;
-const IN_53: usize = 2;
-const OUT_53: usize = 2;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_54: usize = 1;
+const IN_54: usize = 1;
+const OUT_54: usize = 2;
+fn aiur_fn_54(
+  inp: [G; IN_54],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_53], ExecError> {
+) -> Result<[G; OUT_54], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __cu = unconstrained; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_54] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[54].weight(); } record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_55: usize = 2;
+const IN_55: usize = 2;
+const OUT_55: usize = 2;
+fn aiur_fn_55(
+  inp: [G; IN_55],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_55] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; 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 { let __r = record.function_queries[44].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[1];
         let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 5] = [__v_12, __v_2, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_53] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[53].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_55] = [__v_13, __v_11];
+        if !unconstrained { record.virt += record.function_queries[55].weight(); } record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_54: usize = 1;
-const IN_54: usize = 1;
-const OUT_54: usize = 3;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+const INPUT_SIZE_56: usize = 1;
+const IN_56: usize = 1;
+const OUT_56: usize = 4;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __ret: [G; OUT_54] = [__v_3, __v_7, __v_8];
-    if let Some(result) = record.function_queries[54].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_56] = [__v_1, __v_5, __v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[56].weight(); } record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_55: usize = 1;
-const IN_55: usize = 1;
-const OUT_55: usize = 2;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_57: usize = 1;
+const IN_57: usize = 1;
+const OUT_57: usize = 2;
+fn aiur_fn_57(
+  inp: [G; IN_57],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_55], ExecError> {
+) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_55] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[55].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_57] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[57].weight(); } record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_56: usize = 2;
-const IN_56: usize = 2;
-const OUT_56: usize = 2;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+const OUT_58: usize = 2;
+fn aiur_fn_58(
+  inp: [G; IN_58],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_56], ExecError> {
+) -> Result<[G; OUT_58], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_58] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_50(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } } else { aiur_fn_50(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; 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 { let __r = record.function_queries[46].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_7, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_53(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } } else { aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__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_1 - __v_10);
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 4] = [__v_14, __v_4, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_15, __v_13];
-        if let Some(result) = record.function_queries[56].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_58] = [__v_15, __v_13];
+        if !unconstrained { record.virt += record.function_queries[58].weight(); } record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 1;
-const IN_57: usize = 1;
-const OUT_57: usize = 13;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_59: usize = 1;
+const IN_59: usize = 1;
+const OUT_59: usize = 14;
+fn aiur_fn_59(
+  inp: [G; IN_59],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_57], ExecError> {
+) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_12]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __v_15: G = __r_arr[2];
-    let __v_16: G = __r_arr[3];
-    let __v_17: G = __r_arr[4];
-    let __v_18: G = __r_arr[5];
-    let __v_19: G = __r_arr[6];
-    let __v_20: G = __r_arr[7];
-    let __v_21: G = __r_arr[8];
-    let __ret: [G; OUT_57] = [__v_3, __v_5, __v_9, __v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-    if let Some(result) = record.function_queries[57].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_17: G = __r_arr[0];
+    let __v_18: G = __r_arr[1];
+    let __v_19: G = __r_arr[2];
+    let __v_20: G = __r_arr[3];
+    let __v_21: G = __r_arr[4];
+    let __v_22: G = __r_arr[5];
+    let __v_23: G = __r_arr[6];
+    let __v_24: G = __r_arr[7];
+    let __v_25: G = __r_arr[8];
+    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+    if !unconstrained { record.virt += record.function_queries[59].weight(); } record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_58: usize = 1;
-const IN_58: usize = 1;
-const OUT_58: usize = 3;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_60: usize = 1;
+const IN_60: usize = 1;
+const OUT_60: usize = 3;
+fn aiur_fn_60(
+  inp: [G; IN_60],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_58], ExecError> {
+) -> Result<[G; OUT_60], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_25(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } } else { aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(0);
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_58] = [__v_3, __v_4, __v_2];
-        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_58] = [__v_5, __v_3, __v_4];
-        if let Some(result) = record.function_queries[58].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[60].weight(); } record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_59: usize = 1;
-const IN_59: usize = 1;
-const OUT_59: usize = 24;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_61: usize = 1;
+const IN_61: usize = 1;
+const OUT_61: usize = 25;
+fn aiur_fn_61(
+  inp: [G; IN_61],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_59], ExecError> {
+) -> Result<[G; OUT_61], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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 __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_14, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     let __v_18: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_18, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
     let __v_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_24, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
     let __v_26: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_27: G = __r_arr[0];
     let __v_28: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_28]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_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_42] = { let __args: [G; IN_42] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
-    let __v_40: G = __r_arr[0];
-    let __v_41: G = __r_arr[1];
-    let __v_42: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_43: G = __r_arr[0];
-    let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __v_46: G = __r_arr[1];
-    let __ret: [G; OUT_59] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_40, __v_41, __v_43, __v_45, __v_46];
-    if let Some(result) = record.function_queries[59].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_33: G = __r_arr[0];
+    let __v_34: G = __r_arr[1];
+    let __v_35: G = __r_arr[2];
+    let __v_36: G = __r_arr[3];
+    let __v_37: G = __r_arr[4];
+    let __v_38: G = __r_arr[5];
+    let __v_39: G = __r_arr[6];
+    let __v_40: G = __r_arr[7];
+    let __v_41: G = __r_arr[8];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; 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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+    let __v_45: G = __r_arr[1];
+    let __v_46: G = __r_arr[2];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
+    let __v_48: G = __r_arr[1];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __v_50: G = __r_arr[1];
+    let __ret: [G; OUT_61] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50];
+    if !unconstrained { record.virt += record.function_queries[61].weight(); } record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_60: usize = 4;
-const IN_60: usize = 4;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_62: usize = 4;
+const IN_62: usize = 4;
+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_60], ExecError> {
+) -> Result<[G; OUT_62], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2440,22 +2898,23 @@ fn aiur_fn_60(
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = (__v_5 + __v_10);
     let __v_12: G = (__v_0 + __v_11);
-    let __ret: [G; OUT_60] = [__v_12];
-    if let Some(result) = record.function_queries[60].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_62] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[62].weight(); } record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_61: usize = 32;
-const IN_61: usize = 32;
-const OUT_61: usize = 8;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_63: usize = 32;
+const IN_63: usize = 32;
+const OUT_63: usize = 8;
+fn aiur_fn_63(
+  inp: [G; IN_63],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_61], ExecError> {
+) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2560,22 +3019,23 @@ fn aiur_fn_61(
     let __v_101: G = (__v_98 + __v_100);
     let __v_102: G = (__v_96 + __v_101);
     let __v_103: G = (__v_28 + __v_102);
-    let __ret: [G; OUT_61] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
-    if let Some(result) = record.function_queries[61].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_63] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103];
+    if !unconstrained { record.virt += record.function_queries[63].weight(); } record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_62: usize = 1;
-const IN_62: usize = 1;
-const OUT_62: usize = 32;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_64: usize = 1;
+const IN_64: usize = 1;
+const OUT_64: usize = 32;
+fn aiur_fn_64(
+  inp: [G; IN_64],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_62], ExecError> {
+) -> Result<[G; OUT_64], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
     let __v_2: G = G::from_u64(230);
@@ -2611,7 +3071,7 @@ fn aiur_fn_62(
     let __v_32: G = G::from_u64(91);
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -2622,14 +3082,14 @@ fn aiur_fn_62(
     let __v_43: G = G::from_u64(0);
     let __v_44: G = G::from_u64(0);
     let __v_45: G = G::from_u64(0);
-    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_48: G = G::from_u64(1);
     let __v_49: G = G::from_u64(1);
-    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
     let __v_53: G = __r_arr[1];
     let __v_54: G = __r_arr[2];
@@ -2662,22 +3122,127 @@ fn aiur_fn_62(
     let __v_81: G = __r_arr[29];
     let __v_82: G = __r_arr[30];
     let __v_83: G = __r_arr[31];
-    let __ret: [G; OUT_62] = [__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];
-    if let Some(result) = record.function_queries[62].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_64] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83];
+    if !unconstrained { record.virt += record.function_queries[64].weight(); } record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_63: usize = 34;
-const IN_63: usize = 34;
-const OUT_63: usize = 34;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_65: usize = 1;
+const IN_65: usize = 1;
+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_63], ExecError> {
+) -> Result<[G; OUT_65], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(103);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(9);
+    let __v_4: G = G::from_u64(106);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(103);
+    let __v_8: G = G::from_u64(187);
+    let __v_9: G = G::from_u64(114);
+    let __v_10: G = G::from_u64(243);
+    let __v_11: G = G::from_u64(110);
+    let __v_12: G = G::from_u64(60);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(245);
+    let __v_15: G = G::from_u64(79);
+    let __v_16: G = G::from_u64(165);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(82);
+    let __v_19: G = G::from_u64(14);
+    let __v_20: G = G::from_u64(81);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(104);
+    let __v_23: G = G::from_u64(5);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(217);
+    let __v_27: G = G::from_u64(131);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(25);
+    let __v_30: G = G::from_u64(205);
+    let __v_31: G = G::from_u64(224);
+    let __v_32: G = G::from_u64(91);
+    let __v_33: G = G::from_u64(1);
+    let __v_34: G = G::from_u64(1);
+    let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(0);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = G::from_u64(0);
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = G::from_u64(0);
+    let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = G::from_u64(1);
+    let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __v_61: G = __r_arr[9];
+    let __v_62: G = __r_arr[10];
+    let __v_63: G = __r_arr[11];
+    let __v_64: G = __r_arr[12];
+    let __v_65: G = __r_arr[13];
+    let __v_66: G = __r_arr[14];
+    let __v_67: G = __r_arr[15];
+    let __v_68: G = __r_arr[16];
+    let __v_69: G = __r_arr[17];
+    let __v_70: G = __r_arr[18];
+    let __v_71: G = __r_arr[19];
+    let __v_72: G = __r_arr[20];
+    let __v_73: G = __r_arr[21];
+    let __v_74: G = __r_arr[22];
+    let __v_75: G = __r_arr[23];
+    let __v_76: G = __r_arr[24];
+    let __v_77: G = __r_arr[25];
+    let __v_78: G = __r_arr[26];
+    let __v_79: G = __r_arr[27];
+    let __v_80: G = __r_arr[28];
+    let __v_81: G = __r_arr[29];
+    let __v_82: G = __r_arr[30];
+    let __v_83: G = __r_arr[31];
+    let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_65] = [__v_84];
+    if !unconstrained { record.virt += record.function_queries[65].weight(); } record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_66: usize = 34;
+const IN_66: usize = 34;
+const OUT_66: usize = 34;
+fn aiur_fn_66(
+  inp: [G; IN_66],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_66], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -2712,7 +3277,7 @@ fn aiur_fn_63(
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
     let __v_33: G = inp[33];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -2750,13 +3315,13 @@ fn aiur_fn_63(
     match __v_34.as_canonical_u64() {
       1u64 => {
         let __v_68: G = G::from_u64(1);
-        let __ret: [G; OUT_63] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
-        if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_66] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0];
+        if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_68: G = G::from_u64(0);
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_35, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_35, __v_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]; 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 { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } 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_69: G = __r_arr[0];
         let __v_70: G = __r_arr[1];
         let __v_71: G = __r_arr[2];
@@ -2794,8 +3359,8 @@ fn aiur_fn_63(
         match __v_69.as_canonical_u64() {
           0u64 => {
             let __v_103: G = G::from_u64(1);
-            let __ret: [G; OUT_63] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
-            if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_66] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102];
+            if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
@@ -2833,7 +3398,7 @@ fn aiur_fn_63(
             let __v_134: G = G::from_u64(205);
             let __v_135: G = G::from_u64(224);
             let __v_136: G = G::from_u64(91);
-            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+            let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
             let __v_137: G = __loaded[0];
             let __v_138: G = __loaded[1];
             let __v_139: G = __loaded[2];
@@ -2904,7 +3469,7 @@ fn aiur_fn_63(
                 let __v_202: G = G::from_u64(0);
                 let __v_203: G = G::from_u64(0);
                 let __v_204: G = G::from_u64(0);
-                let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_205: G = __r_arr[0];
                 let __v_206: G = __r_arr[1];
                 let __v_207: G = __r_arr[2];
@@ -2940,9 +3505,9 @@ fn aiur_fn_63(
                 let __v_237: G = G::from_u64(0);
                 let __v_238: G = G::from_u64(0);
                 let __v_239: G = G::from_u64(0);
-                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_63] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
-                if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_66] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240];
+                if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -2978,7 +3543,7 @@ fn aiur_fn_63(
                 let __v_200: G = G::from_u64(0);
                 let __v_201: G = G::from_u64(0);
                 let __v_202: G = G::from_u64(0);
-                let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_203: G = __r_arr[0];
                 let __v_204: G = __r_arr[1];
                 let __v_205: G = __r_arr[2];
@@ -3014,9 +3579,9 @@ fn aiur_fn_63(
                 let __v_235: G = G::from_u64(0);
                 let __v_236: G = G::from_u64(0);
                 let __v_237: G = G::from_u64(0);
-                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_63] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
-                if let Some(result) = record.function_queries[63].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_66] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238];
+                if !unconstrained { record.virt += record.function_queries[66].weight(); } record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -3033,18 +3598,19 @@ fn aiur_fn_63(
   })
 }
 
-const INPUT_SIZE_64: usize = 1;
-const IN_64: usize = 1;
-const OUT_64: usize = 32;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_67: usize = 1;
+const IN_67: usize = 1;
+const OUT_67: usize = 32;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+    let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -3081,7 +3647,7 @@ fn aiur_fn_64(
     let __v_34: G = __loaded[33];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
+        let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr };
         let __v_35: G = __loaded[0];
         let __v_36: G = __loaded[1];
         let __v_37: G = __loaded[2];
@@ -3118,13 +3684,13 @@ fn aiur_fn_64(
         let __v_68: G = __loaded[33];
         match __v_35.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34];
-            if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_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];
+            if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_69: G = G::from_u64(1);
-            let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_63(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_63] = unsafe { *(result.output.as_ptr() as *const [G; OUT_63]) }; __ret } } else { aiur_fn_63(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; 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 { let __r = record.function_queries[66].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
             let __v_71: G = __r_arr[1];
             let __v_72: G = __r_arr[2];
@@ -3161,7 +3727,7 @@ fn aiur_fn_64(
             let __v_103: G = __r_arr[33];
             match __v_70.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
                 let __v_105: G = __r_arr[1];
                 let __v_106: G = __r_arr[2];
@@ -3194,14 +3760,14 @@ fn aiur_fn_64(
                 let __v_133: G = __r_arr[29];
                 let __v_134: G = __r_arr[30];
                 let __v_135: G = __r_arr[31];
-                let __ret: [G; OUT_64] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
-                if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_67] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135];
+                if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_104: G = G::from_u64(0);
-                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+                let __v_105: G = { let __values: [G; 34] = [__v_104, __v_103, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_106: G = __r_arr[0];
                 let __v_107: G = __r_arr[1];
                 let __v_108: G = __r_arr[2];
@@ -3234,8 +3800,8 @@ fn aiur_fn_64(
                 let __v_135: G = __r_arr[29];
                 let __v_136: G = __r_arr[30];
                 let __v_137: G = __r_arr[31];
-                let __ret: [G; OUT_64] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
-                if let Some(result) = record.function_queries[64].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_67] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137];
+                if !unconstrained { record.virt += record.function_queries[67].weight(); } record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
@@ -3252,16 +3818,17 @@ fn aiur_fn_64(
   })
 }
 
-const INPUT_SIZE_65: usize = 7;
-const IN_65: usize = 7;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_68: usize = 7;
+const IN_68: usize = 7;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -3269,27 +3836,27 @@ fn aiur_fn_65(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
     let __v_8: G = __loaded[1];
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_68(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } } else { aiur_fn_68(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[71].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_10];
-        if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_68] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(0);
-        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         match __v_2.as_canonical_u64() {
           63u64 => {
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_69(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } } else { aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[72].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_12];
-            if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_68] = [__v_12];
+            if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -3297,10 +3864,10 @@ fn aiur_fn_65(
             let __v_13: G = (__v_2 + __v_12);
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_3 + __v_14);
-            let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
-            let __ret: [G; OUT_65] = [__v_16];
-            if let Some(result) = record.function_queries[65].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_68] = [__v_16];
+            if !unconstrained { record.virt += record.function_queries[68].weight(); } record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -3312,403 +3879,404 @@ fn aiur_fn_65(
   })
 }
 
-const INPUT_SIZE_66: usize = 1;
-const IN_66: usize = 1;
-const OUT_66: usize = 64;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_69: usize = 1;
+const IN_69: usize = 1;
+const OUT_69: usize = 64;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_5: G = __loaded[1];
         let __v_6: G = __loaded[2];
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
             let __v_7: G = __loaded[0];
             let __v_8: G = __loaded[1];
             let __v_9: G = __loaded[2];
             match __v_7.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                 let __v_10: G = __loaded[0];
                 let __v_11: G = __loaded[1];
                 let __v_12: G = __loaded[2];
                 match __v_10.as_canonical_u64() {
                   0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                     let __v_13: G = __loaded[0];
                     let __v_14: G = __loaded[1];
                     let __v_15: G = __loaded[2];
                     match __v_13.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                         let __v_16: G = __loaded[0];
                         let __v_17: G = __loaded[1];
                         let __v_18: G = __loaded[2];
                         match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                             let __v_19: G = __loaded[0];
                             let __v_20: G = __loaded[1];
                             let __v_21: G = __loaded[2];
                             match __v_19.as_canonical_u64() {
                               0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                 let __v_22: G = __loaded[0];
                                 let __v_23: G = __loaded[1];
                                 let __v_24: G = __loaded[2];
                                 match __v_22.as_canonical_u64() {
                                   0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
                                     let __v_26: G = __loaded[1];
                                     let __v_27: G = __loaded[2];
                                     match __v_25.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                         let __v_28: G = __loaded[0];
                                         let __v_29: G = __loaded[1];
                                         let __v_30: G = __loaded[2];
                                         match __v_28.as_canonical_u64() {
                                           0u64 => {
-                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                             let __v_31: G = __loaded[0];
                                             let __v_32: G = __loaded[1];
                                             let __v_33: G = __loaded[2];
                                             match __v_31.as_canonical_u64() {
                                               0u64 => {
-                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                 let __v_34: G = __loaded[0];
                                                 let __v_35: G = __loaded[1];
                                                 let __v_36: G = __loaded[2];
                                                 match __v_34.as_canonical_u64() {
                                                   0u64 => {
-                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                     let __v_37: G = __loaded[0];
                                                     let __v_38: G = __loaded[1];
                                                     let __v_39: G = __loaded[2];
                                                     match __v_37.as_canonical_u64() {
                                                       0u64 => {
-                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                         let __v_40: G = __loaded[0];
                                                         let __v_41: G = __loaded[1];
                                                         let __v_42: G = __loaded[2];
                                                         match __v_40.as_canonical_u64() {
                                                           0u64 => {
-                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                             let __v_43: G = __loaded[0];
                                                             let __v_44: G = __loaded[1];
                                                             let __v_45: G = __loaded[2];
                                                             match __v_43.as_canonical_u64() {
                                                               0u64 => {
-                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                 let __v_46: G = __loaded[0];
                                                                 let __v_47: G = __loaded[1];
                                                                 let __v_48: G = __loaded[2];
                                                                 match __v_46.as_canonical_u64() {
                                                                   0u64 => {
-                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                     let __v_49: G = __loaded[0];
                                                                     let __v_50: G = __loaded[1];
                                                                     let __v_51: G = __loaded[2];
                                                                     match __v_49.as_canonical_u64() {
                                                                       0u64 => {
-                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                         let __v_52: G = __loaded[0];
                                                                         let __v_53: G = __loaded[1];
                                                                         let __v_54: G = __loaded[2];
                                                                         match __v_52.as_canonical_u64() {
                                                                           0u64 => {
-                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                             let __v_55: G = __loaded[0];
                                                                             let __v_56: G = __loaded[1];
                                                                             let __v_57: G = __loaded[2];
                                                                             match __v_55.as_canonical_u64() {
                                                                               0u64 => {
-                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                 let __v_58: G = __loaded[0];
                                                                                 let __v_59: G = __loaded[1];
                                                                                 let __v_60: G = __loaded[2];
                                                                                 match __v_58.as_canonical_u64() {
                                                                                   0u64 => {
-                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                     let __v_61: G = __loaded[0];
                                                                                     let __v_62: G = __loaded[1];
                                                                                     let __v_63: G = __loaded[2];
                                                                                     match __v_61.as_canonical_u64() {
                                                                                       0u64 => {
-                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                         let __v_64: G = __loaded[0];
                                                                                         let __v_65: G = __loaded[1];
                                                                                         let __v_66: G = __loaded[2];
                                                                                         match __v_64.as_canonical_u64() {
                                                                                           0u64 => {
-                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                             let __v_67: G = __loaded[0];
                                                                                             let __v_68: G = __loaded[1];
                                                                                             let __v_69: G = __loaded[2];
                                                                                             match __v_67.as_canonical_u64() {
                                                                                               0u64 => {
-                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                 let __v_70: G = __loaded[0];
                                                                                                 let __v_71: G = __loaded[1];
                                                                                                 let __v_72: G = __loaded[2];
                                                                                                 match __v_70.as_canonical_u64() {
                                                                                                   0u64 => {
-                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                     let __v_73: G = __loaded[0];
                                                                                                     let __v_74: G = __loaded[1];
                                                                                                     let __v_75: G = __loaded[2];
                                                                                                     match __v_73.as_canonical_u64() {
                                                                                                       0u64 => {
-                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                         let __v_76: G = __loaded[0];
                                                                                                         let __v_77: G = __loaded[1];
                                                                                                         let __v_78: G = __loaded[2];
                                                                                                         match __v_76.as_canonical_u64() {
                                                                                                           0u64 => {
-                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                             let __v_79: G = __loaded[0];
                                                                                                             let __v_80: G = __loaded[1];
                                                                                                             let __v_81: G = __loaded[2];
                                                                                                             match __v_79.as_canonical_u64() {
                                                                                                               0u64 => {
-                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                 let __v_82: G = __loaded[0];
                                                                                                                 let __v_83: G = __loaded[1];
                                                                                                                 let __v_84: G = __loaded[2];
                                                                                                                 match __v_82.as_canonical_u64() {
                                                                                                                   0u64 => {
-                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                     let __v_85: G = __loaded[0];
                                                                                                                     let __v_86: G = __loaded[1];
                                                                                                                     let __v_87: G = __loaded[2];
                                                                                                                     match __v_85.as_canonical_u64() {
                                                                                                                       0u64 => {
-                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                         let __v_88: G = __loaded[0];
                                                                                                                         let __v_89: G = __loaded[1];
                                                                                                                         let __v_90: G = __loaded[2];
                                                                                                                         match __v_88.as_canonical_u64() {
                                                                                                                           0u64 => {
-                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                             let __v_91: G = __loaded[0];
                                                                                                                             let __v_92: G = __loaded[1];
                                                                                                                             let __v_93: G = __loaded[2];
                                                                                                                             match __v_91.as_canonical_u64() {
                                                                                                                               0u64 => {
-                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                 let __v_94: G = __loaded[0];
                                                                                                                                 let __v_95: G = __loaded[1];
                                                                                                                                 let __v_96: G = __loaded[2];
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
-                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                     let __v_97: G = __loaded[0];
                                                                                                                                     let __v_98: G = __loaded[1];
                                                                                                                                     let __v_99: G = __loaded[2];
                                                                                                                                     match __v_97.as_canonical_u64() {
                                                                                                                                       0u64 => {
-                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                         let __v_100: G = __loaded[0];
                                                                                                                                         let __v_101: G = __loaded[1];
                                                                                                                                         let __v_102: G = __loaded[2];
                                                                                                                                         match __v_100.as_canonical_u64() {
                                                                                                                                           0u64 => {
-                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                             let __v_103: G = __loaded[0];
                                                                                                                                             let __v_104: G = __loaded[1];
                                                                                                                                             let __v_105: G = __loaded[2];
                                                                                                                                             match __v_103.as_canonical_u64() {
                                                                                                                                               0u64 => {
-                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                 let __v_106: G = __loaded[0];
                                                                                                                                                 let __v_107: G = __loaded[1];
                                                                                                                                                 let __v_108: G = __loaded[2];
                                                                                                                                                 match __v_106.as_canonical_u64() {
                                                                                                                                                   0u64 => {
-                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                     let __v_109: G = __loaded[0];
                                                                                                                                                     let __v_110: G = __loaded[1];
                                                                                                                                                     let __v_111: G = __loaded[2];
                                                                                                                                                     match __v_109.as_canonical_u64() {
                                                                                                                                                       0u64 => {
-                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                         let __v_112: G = __loaded[0];
                                                                                                                                                         let __v_113: G = __loaded[1];
                                                                                                                                                         let __v_114: G = __loaded[2];
                                                                                                                                                         match __v_112.as_canonical_u64() {
                                                                                                                                                           0u64 => {
-                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                             let __v_115: G = __loaded[0];
                                                                                                                                                             let __v_116: G = __loaded[1];
                                                                                                                                                             let __v_117: G = __loaded[2];
                                                                                                                                                             match __v_115.as_canonical_u64() {
                                                                                                                                                               0u64 => {
-                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                 let __v_118: G = __loaded[0];
                                                                                                                                                                 let __v_119: G = __loaded[1];
                                                                                                                                                                 let __v_120: G = __loaded[2];
                                                                                                                                                                 match __v_118.as_canonical_u64() {
                                                                                                                                                                   0u64 => {
-                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                     let __v_121: G = __loaded[0];
                                                                                                                                                                     let __v_122: G = __loaded[1];
                                                                                                                                                                     let __v_123: G = __loaded[2];
                                                                                                                                                                     match __v_121.as_canonical_u64() {
                                                                                                                                                                       0u64 => {
-                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                         let __v_124: G = __loaded[0];
                                                                                                                                                                         let __v_125: G = __loaded[1];
                                                                                                                                                                         let __v_126: G = __loaded[2];
                                                                                                                                                                         match __v_124.as_canonical_u64() {
                                                                                                                                                                           0u64 => {
-                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                             let __v_127: G = __loaded[0];
                                                                                                                                                                             let __v_128: G = __loaded[1];
                                                                                                                                                                             let __v_129: G = __loaded[2];
                                                                                                                                                                             match __v_127.as_canonical_u64() {
                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                 let __v_130: G = __loaded[0];
                                                                                                                                                                                 let __v_131: G = __loaded[1];
                                                                                                                                                                                 let __v_132: G = __loaded[2];
                                                                                                                                                                                 match __v_130.as_canonical_u64() {
                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                     let __v_133: G = __loaded[0];
                                                                                                                                                                                     let __v_134: G = __loaded[1];
                                                                                                                                                                                     let __v_135: G = __loaded[2];
                                                                                                                                                                                     match __v_133.as_canonical_u64() {
                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                         let __v_136: G = __loaded[0];
                                                                                                                                                                                         let __v_137: G = __loaded[1];
                                                                                                                                                                                         let __v_138: G = __loaded[2];
                                                                                                                                                                                         match __v_136.as_canonical_u64() {
                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                             let __v_139: G = __loaded[0];
                                                                                                                                                                                             let __v_140: G = __loaded[1];
                                                                                                                                                                                             let __v_141: G = __loaded[2];
                                                                                                                                                                                             match __v_139.as_canonical_u64() {
                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                 let __v_142: G = __loaded[0];
                                                                                                                                                                                                 let __v_143: G = __loaded[1];
                                                                                                                                                                                                 let __v_144: G = __loaded[2];
                                                                                                                                                                                                 match __v_142.as_canonical_u64() {
                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                     let __v_145: G = __loaded[0];
                                                                                                                                                                                                     let __v_146: G = __loaded[1];
                                                                                                                                                                                                     let __v_147: G = __loaded[2];
                                                                                                                                                                                                     match __v_145.as_canonical_u64() {
                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                         let __v_148: G = __loaded[0];
                                                                                                                                                                                                         let __v_149: G = __loaded[1];
                                                                                                                                                                                                         let __v_150: G = __loaded[2];
                                                                                                                                                                                                         match __v_148.as_canonical_u64() {
                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                             let __v_151: G = __loaded[0];
                                                                                                                                                                                                             let __v_152: G = __loaded[1];
                                                                                                                                                                                                             let __v_153: G = __loaded[2];
                                                                                                                                                                                                             match __v_151.as_canonical_u64() {
                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                 let __v_154: G = __loaded[0];
                                                                                                                                                                                                                 let __v_155: G = __loaded[1];
                                                                                                                                                                                                                 let __v_156: G = __loaded[2];
                                                                                                                                                                                                                 match __v_154.as_canonical_u64() {
                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                     let __v_157: G = __loaded[0];
                                                                                                                                                                                                                     let __v_158: G = __loaded[1];
                                                                                                                                                                                                                     let __v_159: G = __loaded[2];
                                                                                                                                                                                                                     match __v_157.as_canonical_u64() {
                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                         let __v_160: G = __loaded[0];
                                                                                                                                                                                                                         let __v_161: G = __loaded[1];
                                                                                                                                                                                                                         let __v_162: G = __loaded[2];
                                                                                                                                                                                                                         match __v_160.as_canonical_u64() {
                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                             let __v_163: G = __loaded[0];
                                                                                                                                                                                                                             let __v_164: G = __loaded[1];
                                                                                                                                                                                                                             let __v_165: G = __loaded[2];
                                                                                                                                                                                                                             match __v_163.as_canonical_u64() {
                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                 let __v_166: G = __loaded[0];
                                                                                                                                                                                                                                 let __v_167: G = __loaded[1];
                                                                                                                                                                                                                                 let __v_168: G = __loaded[2];
                                                                                                                                                                                                                                 match __v_166.as_canonical_u64() {
                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                     let __v_169: G = __loaded[0];
                                                                                                                                                                                                                                     let __v_170: G = __loaded[1];
                                                                                                                                                                                                                                     let __v_171: G = __loaded[2];
                                                                                                                                                                                                                                     match __v_169.as_canonical_u64() {
                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                         let __v_172: G = __loaded[0];
                                                                                                                                                                                                                                         let __v_173: G = __loaded[1];
                                                                                                                                                                                                                                         let __v_174: G = __loaded[2];
                                                                                                                                                                                                                                         match __v_172.as_canonical_u64() {
                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                             let __v_175: G = __loaded[0];
                                                                                                                                                                                                                                             let __v_176: G = __loaded[1];
                                                                                                                                                                                                                                             let __v_177: G = __loaded[2];
                                                                                                                                                                                                                                             match __v_175.as_canonical_u64() {
                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                 let __v_178: G = __loaded[0];
                                                                                                                                                                                                                                                 let __v_179: G = __loaded[1];
                                                                                                                                                                                                                                                 let __v_180: G = __loaded[2];
                                                                                                                                                                                                                                                 match __v_178.as_canonical_u64() {
                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                     let __v_181: G = __loaded[0];
                                                                                                                                                                                                                                                     let __v_182: G = __loaded[1];
                                                                                                                                                                                                                                                     let __v_183: G = __loaded[2];
                                                                                                                                                                                                                                                     match __v_181.as_canonical_u64() {
                                                                                                                                                                                                                                                       0u64 => {
-                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                         let __v_184: G = __loaded[0];
                                                                                                                                                                                                                                                         let __v_185: G = __loaded[1];
                                                                                                                                                                                                                                                         let __v_186: G = __loaded[2];
                                                                                                                                                                                                                                                         match __v_184.as_canonical_u64() {
                                                                                                                                                                                                                                                           0u64 => {
-                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                             let __v_187: G = __loaded[0];
                                                                                                                                                                                                                                                             let __v_188: G = __loaded[1];
                                                                                                                                                                                                                                                             let __v_189: G = __loaded[2];
                                                                                                                                                                                                                                                             match __v_187.as_canonical_u64() {
                                                                                                                                                                                                                                                               0u64 => {
-                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
                                                                                                                                                                                                                                                                 let __v_190: G = __loaded[0];
                                                                                                                                                                                                                                                                 let __v_191: G = __loaded[1];
                                                                                                                                                                                                                                                                 let __v_192: G = __loaded[2];
                                                                                                                                                                                                                                                                 match __v_190.as_canonical_u64() {
                                                                                                                                                                                                                                                                   0u64 => {
-                                                                                                                                                                                                                                                                    let __ret: [G; OUT_66] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
-                                                                                                                                                                                                                                                                    if let Some(result) = record.function_queries[66].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                                                                                                                                                                                                                                                    let __ret: [G; OUT_69] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2];
+                                                                                                                                                                                                                                                                    if !unconstrained { record.virt += record.function_queries[69].weight(); } record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                                                                                                                                                                                                                                                     return Ok(__ret);
                                                                                                                                                                                                                                                                   },
                                                                                                                                                                                                                                                                   _ => {
@@ -4033,50 +4601,52 @@ fn aiur_fn_66(
   })
 }
 
-const INPUT_SIZE_67: usize = 2;
-const IN_67: usize = 2;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_70: usize = 2;
+const IN_70: usize = 2;
+const OUT_70: usize = 1;
+fn aiur_fn_70(
+  inp: [G; IN_70],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_67], ExecError> {
+) -> Result<[G; OUT_70], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_67] = [__v_0];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_70] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(0);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 - __v_5);
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; 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 { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-        let __ret: [G; OUT_67] = [__v_7];
-        if let Some(result) = record.function_queries[67].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_70] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[70].weight(); } record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_68: usize = 6;
-const IN_68: usize = 6;
-const OUT_68: usize = 1;
-fn aiur_fn_68(
-  inp: [G; IN_68],
+const INPUT_SIZE_71: usize = 6;
+const IN_71: usize = 6;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -4090,7 +4660,7 @@ fn aiur_fn_68(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
             let __v_9: G = __loaded[0];
             let __v_10: G = __loaded[1];
             let __v_11: G = __loaded[2];
@@ -4117,7 +4687,7 @@ fn aiur_fn_68(
                                           0u64 => {
                                             let __v_17: G = (__v_6 + __v_7);
                                             let __v_18: G = (__v_8 + __v_17);
-                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
                                             let __v_19: G = __loaded[0];
                                             let __v_20: G = __loaded[1];
                                             let __v_21: G = __loaded[2];
@@ -4214,7 +4784,7 @@ fn aiur_fn_68(
                                             let __v_112: G = G::from_u64(0);
                                             let __v_113: G = G::from_u64(0);
                                             let __v_114: G = G::from_u64(0);
-                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                            let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
                                             let __v_115: G = __loaded[0];
                                             let __v_116: G = __loaded[1];
                                             let __v_117: G = __loaded[2];
@@ -4248,7 +4818,7 @@ fn aiur_fn_68(
                                             let __v_145: G = G::from_u64(0);
                                             let __v_146: G = G::from_u64(0);
                                             let __v_147: G = G::from_u64(0);
-                                            let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_148: G = __r_arr[0];
                                             let __v_149: G = __r_arr[1];
                                             let __v_150: G = __r_arr[2];
@@ -4281,70 +4851,70 @@ fn aiur_fn_68(
                                             let __v_177: G = __r_arr[29];
                                             let __v_178: G = __r_arr[30];
                                             let __v_179: G = __r_arr[31];
-                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_68] = [__v_180];
-                                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                            let __ret: [G; OUT_71] = [__v_180];
+                                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __ret: [G; OUT_68] = [__v_5];
-                                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                            let __ret: [G; OUT_71] = [__v_5];
+                                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                             return Ok(__ret);
                                           },
                                         }
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_68] = [__v_5];
-                                        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_71] = [__v_5];
+                                        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_68] = [__v_5];
-                                    if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_71] = [__v_5];
+                                    if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_68] = [__v_5];
-                                if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_71] = [__v_5];
+                                if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_68] = [__v_5];
-                            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_71] = [__v_5];
+                            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_68] = [__v_5];
-                        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_71] = [__v_5];
+                        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_68] = [__v_5];
-                    if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_71] = [__v_5];
+                    if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_68] = [__v_5];
-                if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_71] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+            let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
             let __v_10: G = __loaded[0];
             let __v_11: G = __loaded[1];
             let __v_12: G = __loaded[2];
@@ -4377,15 +4947,15 @@ fn aiur_fn_68(
             let __v_39: G = __loaded[29];
             let __v_40: G = __loaded[30];
             let __v_41: G = __loaded[31];
-            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_68] = [__v_42];
-            if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_71] = [__v_42];
+            if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
         let __v_10: G = __loaded[1];
         let __v_11: G = __loaded[2];
@@ -4394,7 +4964,7 @@ fn aiur_fn_68(
         let __v_14: G = __loaded[5];
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __v_18: G = (__v_17 * __v_8);
         let __v_19: G = (__v_2 - __v_1);
@@ -4404,9 +4974,9 @@ fn aiur_fn_68(
         let __v_23: G = (__v_7 + __v_22);
         let __v_24: G = G::from_u64(64);
         let __v_25: G = (__v_24 - __v_1);
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_67(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } } else { aiur_fn_67(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; 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 { let __r = record.function_queries[70].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; 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 { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
         let __v_28: G = __r_arr[1];
         let __v_29: G = __r_arr[2];
@@ -4471,7 +5041,7 @@ fn aiur_fn_68(
         let __v_88: G = __r_arr[61];
         let __v_89: G = __r_arr[62];
         let __v_90: G = __r_arr[63];
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_91: G = __loaded[0];
         let __v_92: G = __loaded[1];
         let __v_93: G = __loaded[2];
@@ -4504,7 +5074,7 @@ fn aiur_fn_68(
         let __v_120: G = __loaded[29];
         let __v_121: G = __loaded[30];
         let __v_122: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_123: G = __loaded[0];
         let __v_124: G = __loaded[1];
         let __v_125: G = __loaded[2];
@@ -4537,7 +5107,7 @@ fn aiur_fn_68(
         let __v_152: G = G::from_u64(0);
         let __v_153: G = G::from_u64(0);
         let __v_154: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
         let __v_156: G = __r_arr[1];
         let __v_157: G = __r_arr[2];
@@ -4570,25 +5140,26 @@ fn aiur_fn_68(
         let __v_184: G = __r_arr[29];
         let __v_185: G = __r_arr[30];
         let __v_186: G = __r_arr[31];
-        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_68] = [__v_187];
-        if let Some(result) = record.function_queries[68].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_71] = [__v_187];
+        if !unconstrained { record.virt += record.function_queries[71].weight(); } record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_69: usize = 6;
-const IN_69: usize = 6;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+const INPUT_SIZE_72: usize = 6;
+const IN_72: usize = 6;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -4598,7 +5169,7 @@ fn aiur_fn_69(
     let __v_6: G = G::from_u64(1);
     let __v_7: G = G::from_u64(2);
     let __v_8: G = G::from_u64(8);
-    let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[66].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_66(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_66] = unsafe { *(result.output.as_ptr() as *const [G; OUT_66]) }; __ret } } else { aiur_fn_66(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; 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 { let __r = record.function_queries[69].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     let __v_11: G = __r_arr[2];
@@ -4665,9 +5236,9 @@ fn aiur_fn_69(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0]; 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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_75: G = __loaded[1];
         let __v_76: G = __loaded[2];
@@ -4676,7 +5247,7 @@ fn aiur_fn_69(
         let __v_79: G = __loaded[5];
         let __v_80: G = __loaded[6];
         let __v_81: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
         let __v_83: G = (__v_73 * __v_82);
         let __v_84: G = (__v_8 * __v_83);
@@ -4713,7 +5284,7 @@ fn aiur_fn_69(
         let __v_115: G = G::from_u64(205);
         let __v_116: G = G::from_u64(224);
         let __v_117: G = G::from_u64(91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_118: G = __loaded[0];
         let __v_119: G = __loaded[1];
         let __v_120: G = __loaded[2];
@@ -4746,7 +5317,7 @@ fn aiur_fn_69(
         let __v_147: G = __loaded[29];
         let __v_148: G = __loaded[30];
         let __v_149: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_150: G = __loaded[0];
         let __v_151: G = __loaded[1];
         let __v_152: G = __loaded[2];
@@ -4780,7 +5351,7 @@ fn aiur_fn_69(
         let __v_180: G = G::from_u64(0);
         let __v_181: G = G::from_u64(0);
         let __v_182: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_183: G = __r_arr[0];
         let __v_184: G = __r_arr[1];
         let __v_185: G = __r_arr[2];
@@ -4813,13 +5384,13 @@ fn aiur_fn_69(
         let __v_212: G = __r_arr[29];
         let __v_213: G = __r_arr[30];
         let __v_214: G = __r_arr[31];
-        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_216: G = G::from_u64(1);
         let __v_217: G = G::from_u64(1);
-        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_219: G = G::from_u64(0);
         let __v_220: G = G::from_u64(0);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_221: G = __loaded[0];
         let __v_222: G = __loaded[1];
         let __v_223: G = __loaded[2];
@@ -4828,7 +5399,7 @@ fn aiur_fn_69(
         let __v_226: G = __loaded[5];
         let __v_227: G = __loaded[6];
         let __v_228: G = __loaded[7];
-        let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[12].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } };
         let __v_229: G = __r_arr[0];
         let __v_230: G = __r_arr[1];
         let __v_231: G = __r_arr[2];
@@ -4837,21 +5408,21 @@ fn aiur_fn_69(
         let __v_234: G = __r_arr[5];
         let __v_235: G = __r_arr[6];
         let __v_236: G = __r_arr[7];
-        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_239: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_239];
-        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_72] = [__v_239];
+        if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0]; 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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
         let __v_74: G = (__v_73 * __v_7);
-        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0]; 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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_77: G = __loaded[1];
         let __v_78: G = __loaded[2];
@@ -4860,7 +5431,7 @@ fn aiur_fn_69(
         let __v_81: G = __loaded[5];
         let __v_82: G = __loaded[6];
         let __v_83: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_84: G = __r_arr[0];
         let __v_85: G = (__v_84 * __v_8);
         let __v_86: G = (__v_75 * __v_85);
@@ -4870,7 +5441,7 @@ fn aiur_fn_69(
         let __v_90: G = (__v_89 * __v_6);
         let __v_91: G = (__v_86 + __v_90);
         let __v_92: G = (__v_74 + __v_91);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_93: G = __loaded[0];
         let __v_94: G = __loaded[1];
         let __v_95: G = __loaded[2];
@@ -4903,7 +5474,7 @@ fn aiur_fn_69(
         let __v_122: G = __loaded[29];
         let __v_123: G = __loaded[30];
         let __v_124: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_125: G = __loaded[0];
         let __v_126: G = __loaded[1];
         let __v_127: G = __loaded[2];
@@ -4936,7 +5507,7 @@ fn aiur_fn_69(
         let __v_154: G = G::from_u64(0);
         let __v_155: G = G::from_u64(0);
         let __v_156: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_157: G = __r_arr[0];
         let __v_158: G = __r_arr[1];
         let __v_159: G = __r_arr[2];
@@ -4971,31 +5542,32 @@ fn aiur_fn_69(
         let __v_188: G = __r_arr[31];
         let __v_189: G = G::from_u64(1);
         let __v_190: G = G::from_u64(1);
-        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_192: G = G::from_u64(0);
         let __v_193: G = G::from_u64(1);
         let __v_194: G = (__v_2 + __v_193);
-        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_196: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_196];
-        if let Some(result) = record.function_queries[69].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_72] = [__v_196];
+        if !unconstrained { record.virt += record.function_queries[72].weight(); } record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_70: usize = 24;
-const IN_70: usize = 24;
-const OUT_70: usize = 16;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+const INPUT_SIZE_73: usize = 24;
+const IN_73: usize = 24;
+const OUT_73: usize = 16;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -5124,22 +5696,23 @@ fn aiur_fn_70(
     let __v_89: G = (__v_82 + __v_85);
     let __v_90: G = (__v_84 + __v_87);
     let __v_91: G = (__v_86 + __v_81);
-    let __ret: [G; OUT_70] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
-    if let Some(result) = record.function_queries[70].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_73] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70];
+    if !unconstrained { record.virt += record.function_queries[73].weight(); } record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_71: usize = 128;
-const IN_71: usize = 128;
-const OUT_71: usize = 128;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_74: usize = 128;
+const IN_74: usize = 128;
+const OUT_74: usize = 128;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -6100,22 +6673,23 @@ fn aiur_fn_71(
     let __v_669: G = (__v_662 + __v_665);
     let __v_670: G = (__v_664 + __v_667);
     let __v_671: G = (__v_666 + __v_661);
-    let __ret: [G; OUT_71] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
-    if let Some(result) = record.function_queries[71].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_74] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127];
+    if !unconstrained { record.virt += record.function_queries[74].weight(); } record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_72: usize = 106;
-const IN_72: usize = 106;
-const OUT_72: usize = 32;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_75: usize = 106;
+const IN_75: usize = 106;
+const OUT_75: usize = 32;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -6245,7 +6819,7 @@ fn aiur_fn_72(
     let __v_126: G = G::from_u64(0);
     let __v_127: G = G::from_u64(0);
     let __v_128: G = G::from_u64(0);
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
     let __v_130: G = __r_arr[1];
     let __v_131: G = __r_arr[2];
@@ -6278,22 +6852,23 @@ fn aiur_fn_72(
     let __v_158: G = __r_arr[29];
     let __v_159: G = __r_arr[30];
     let __v_160: G = __r_arr[31];
-    let __ret: [G; OUT_72] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-    if let Some(result) = record.function_queries[72].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_75] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+    if !unconstrained { record.virt += record.function_queries[75].weight(); } record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_73: usize = 129;
-const IN_73: usize = 129;
-const OUT_73: usize = 32;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_76: usize = 129;
+const IN_76: usize = 129;
+const OUT_76: usize = 32;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -6457,8 +7032,8 @@ fn aiur_fn_73(
         let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) };
         let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) };
         let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) };
-        let __ret: [G; OUT_73] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_76] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160];
+        if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -7296,7 +7871,7 @@ fn aiur_fn_73(
         let __v_672: G = (__v_667 + __v_662);
         let __v_673: G = G::from_u64(1);
         let __v_674: G = (__v_0 + __v_673);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_675: G = __r_arr[0];
         let __v_676: G = __r_arr[1];
         let __v_677: G = __r_arr[2];
@@ -7329,33 +7904,34 @@ fn aiur_fn_73(
         let __v_704: G = __r_arr[29];
         let __v_705: G = __r_arr[30];
         let __v_706: G = __r_arr[31];
-        let __ret: [G; OUT_73] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
-        if let Some(result) = record.function_queries[73].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_76] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706];
+        if !unconstrained { record.virt += record.function_queries[76].weight(); } record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 2;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __ret: [G; OUT_74] = [__v_2, __v_3];
-        if let Some(result) = record.function_queries[74].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_77] = [__v_2, __v_3];
+        if !unconstrained { record.virt += record.function_queries[77].weight(); } record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -7365,67 +7941,70 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 1;
-const IN_75: usize = 1;
-const OUT_75: usize = 2;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_78: usize = 1;
+const IN_78: usize = 1;
+const OUT_78: usize = 2;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_75] = [__v_1, __v_2];
-    if let Some(result) = record.function_queries[75].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_78] = [__v_1, __v_2];
+    if !unconstrained { record.virt += record.function_queries[78].weight(); } record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 2;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_79: usize = 1;
+const IN_79: usize = 1;
+const OUT_79: usize = 2;
+fn aiur_fn_79(
+  inp: [G; IN_79],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_76], ExecError> {
+) -> Result<[G; OUT_79], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(256);
     let __v_6: G = (__v_5 * __v_3);
     let __v_7: G = (__v_1 + __v_6);
-    let __ret: [G; OUT_76] = [__v_7, __v_4];
-    if let Some(result) = record.function_queries[76].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_79] = [__v_7, __v_4];
+    if !unconstrained { record.virt += record.function_queries[79].weight(); } record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_77: usize = 1;
-const IN_77: usize = 1;
-const OUT_77: usize = 10;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(256);
@@ -7437,33 +8016,34 @@ fn aiur_fn_77(
     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 __ret: [G; OUT_77] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4];
-    if let Some(result) = record.function_queries[77].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_80] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4];
+    if !unconstrained { record.virt += record.function_queries[80].weight(); } record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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(256);
@@ -7479,65 +8059,67 @@ fn aiur_fn_78(
     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 __ret: [G; OUT_78] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8];
-    if let Some(result) = record.function_queries[78].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_81] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8];
+    if !unconstrained { record.virt += record.function_queries[81].weight(); } record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_79: usize = 1;
-const IN_79: usize = 1;
-const OUT_79: usize = 9;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_82: usize = 1;
+const IN_82: usize = 1;
+const OUT_82: usize = 9;
+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 __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_74] = { let __args: [G; IN_74] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __ret: [G; OUT_79] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
-    if let Some(result) = record.function_queries[79].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_82] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16];
+    if !unconstrained { record.virt += record.function_queries[82].weight(); } record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_80: usize = 1;
-const IN_80: usize = 1;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
+const INPUT_SIZE_83: usize = 1;
+const IN_83: usize = 1;
+const OUT_83: usize = 2;
+fn aiur_fn_83(
+  inp: [G; IN_83],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
+) -> Result<[G; OUT_83], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -7568,24 +8150,25 @@ fn aiur_fn_80(
     let __v_28: G = (__v_13 + __v_27);
     let __v_29: G = (__v_11 + __v_28);
     let __v_30: G = (__v_1 + __v_29);
-    let __ret: [G; OUT_80] = [__v_30, __v_9];
-    if let Some(result) = record.function_queries[80].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_83] = [__v_30, __v_9];
+    if !unconstrained { record.virt += record.function_queries[83].weight(); } record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_81: usize = 1;
-const IN_81: usize = 1;
-const OUT_81: usize = 33;
-fn aiur_fn_81(
-  inp: [G; IN_81],
+const INPUT_SIZE_84: usize = 1;
+const IN_84: usize = 1;
+const OUT_84: usize = 33;
+fn aiur_fn_84(
+  inp: [G; IN_84],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_81], ExecError> {
+) -> Result<[G; OUT_84], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -7595,7 +8178,7 @@ fn aiur_fn_81(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -7605,7 +8188,7 @@ fn aiur_fn_81(
     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_79] = { let __args: [G; IN_79] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
     let __v_21: G = __r_arr[2];
@@ -7615,7 +8198,7 @@ fn aiur_fn_81(
     let __v_25: G = __r_arr[6];
     let __v_26: G = __r_arr[7];
     let __v_27: G = __r_arr[8];
-    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -7625,35 +8208,36 @@ fn aiur_fn_81(
     let __v_34: G = __r_arr[6];
     let __v_35: G = __r_arr[7];
     let __v_36: G = __r_arr[8];
-    let __ret: [G; OUT_81] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-    if let Some(result) = record.function_queries[81].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+    if !unconstrained { record.virt += record.function_queries[84].weight(); } record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_82: usize = 2;
-const IN_82: usize = 2;
-const OUT_82: usize = 2;
-fn aiur_fn_82(
-  inp: [G; IN_82],
+const INPUT_SIZE_85: usize = 2;
+const IN_85: usize = 2;
+const OUT_85: usize = 2;
+fn aiur_fn_85(
+  inp: [G; IN_85],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
+) -> Result<[G; OUT_85], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_85] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -7663,7 +8247,7 @@ fn aiur_fn_82(
         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_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -7673,7 +8257,7 @@ fn aiur_fn_82(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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 = __r_arr[2];
@@ -7683,7 +8267,7 @@ fn aiur_fn_82(
         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_79] = { let __args: [G; IN_79] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_79(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } } else { aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_28]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
         let __v_30: G = __r_arr[1];
         let __v_31: G = __r_arr[2];
@@ -7695,322 +8279,323 @@ fn aiur_fn_82(
         let __v_37: G = __r_arr[8];
         let __v_38: G = G::from_u64(1);
         let __v_39: G = (__v_1 - __v_38);
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
         let __v_41: G = __r_arr[1];
         let __v_42: G = G::from_u64(0);
-        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_82] = [__v_44, __v_41];
-        if let Some(result) = record.function_queries[82].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_85] = [__v_44, __v_41];
+        if !unconstrained { record.virt += record.function_queries[85].weight(); } record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_83: usize = 2;
-const IN_83: usize = 2;
-const OUT_83: usize = 2;
-fn aiur_fn_83(
-  inp: [G; IN_83],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_83], ExecError> {
+const INPUT_SIZE_86: usize = 2;
+const IN_86: usize = 2;
+const OUT_86: usize = 2;
+fn aiur_fn_86(
+  inp: [G; IN_86],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_86], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_86] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_80(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } } else { aiur_fn_80(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; 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 { let __r = record.function_queries[83].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
             let __v_5: G = __r_arr[1];
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(0);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
             let __v_5: G = __r_arr[1];
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(2);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           3u64 => {
             let __v_4: G = G::from_u64(1);
             let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(3);
             let __v_10: G = G::from_u64(3);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           4u64 => {
             let __v_4: G = G::from_u64(1);
             let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(4);
             let __v_10: G = G::from_u64(4);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           5u64 => {
             let __v_4: G = G::from_u64(1);
             let __v_5: G = (__v_1 - __v_4);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(5);
             let __v_10: G = G::from_u64(5);
-            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(6);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(7);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           8u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
             let __v_7: G = __r_arr[1];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_1 - __v_8);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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 __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(8);
             let __v_14: G = G::from_u64(0);
-            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_15, __v_11];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_15, __v_11];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           9u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(9);
             let __v_12: G = G::from_u64(0);
-            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_13, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_13, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           10u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(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; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           11u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           12u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           13u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
             let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           14u64 => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(2);
             let __v_13: G = G::from_u64(0);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             let __v_10: G = G::from_u64(0);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(2);
             let __v_13: G = G::from_u64(1);
-            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_83] = [__v_14, __v_9];
-            if let Some(result) = record.function_queries[83].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_86] = [__v_14, __v_9];
+            if !unconstrained { record.virt += record.function_queries[86].weight(); } record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -8019,136 +8604,160 @@ fn aiur_fn_83(
   })
 }
 
-const INPUT_SIZE_84: usize = 2;
-const IN_84: usize = 2;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+const INPUT_SIZE_87: usize = 2;
+const IN_87: usize = 2;
+const OUT_87: usize = 2;
+fn aiur_fn_87(
+  inp: [G; IN_87],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_84], ExecError> {
+) -> Result<[G; OUT_87], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
         let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = G::from_u64(0);
-        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_9, __v_7];
-        if let Some(result) = record.function_queries[84].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_87] = [__v_9, __v_7];
+        if !unconstrained { record.virt += record.function_queries[87].weight(); } record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_85: usize = 1;
-const IN_85: usize = 1;
-const OUT_85: usize = 3;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+const INPUT_SIZE_88: usize = 1;
+const IN_88: usize = 1;
+const OUT_88: usize = 3;
+fn aiur_fn_88(
+  inp: [G; IN_88],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_2]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = __r_arr[1];
-    let __ret: [G; OUT_85] = [__v_1, __v_5, __v_6];
-    if let Some(result) = record.function_queries[85].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __v_11: G = __r_arr[8];
+    let __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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_13, __v_12]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __ret: [G; OUT_88] = [__v_1, __v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[88].weight(); } record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_86: usize = 2;
-const IN_86: usize = 2;
-const OUT_86: usize = 2;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_89: usize = 2;
+const IN_89: usize = 2;
+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_86], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_3]; 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 { let __r = record.function_queries[82].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __v_7: G = __r_arr[1];
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = (__v_1 - __v_8);
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = G::from_u64(0);
-        let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_86] = [__v_13, __v_11];
-        if let Some(result) = record.function_queries[86].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_6: G = __r_arr[2];
+        let __v_7: G = __r_arr[3];
+        let __v_8: G = __r_arr[4];
+        let __v_9: G = __r_arr[5];
+        let __v_10: G = __r_arr[6];
+        let __v_11: G = __r_arr[7];
+        let __v_12: G = __r_arr[8];
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_12]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_14, __v_13]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        let __v_17: G = G::from_u64(1);
+        let __v_18: G = (__v_1 - __v_17);
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_16, __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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = { let __values: [G; 4] = [__v_21, __v_2, __v_15, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_89] = [__v_22, __v_20];
+        if !unconstrained { record.virt += record.function_queries[89].weight(); } record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_87: usize = 3;
-const IN_87: usize = 3;
-const OUT_87: usize = 1;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_90: usize = 3;
+const IN_90: usize = 3;
+const OUT_90: usize = 1;
+fn aiur_fn_90(
+  inp: [G; IN_90],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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 __v_3: G = G::from_u64(0);
-        let __ret: [G; OUT_87] = [__v_3];
-        if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_90] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -8159,11 +8768,11 @@ fn aiur_fn_87(
             let __v_5: G = (__v_0 - __v_4);
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_2 - __v_6);
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
             let __v_9: G = (__v_3 + __v_8);
-            let __ret: [G; OUT_87] = [__v_9];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_90] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -8171,10 +8780,10 @@ fn aiur_fn_87(
             let __v_4: G = (__v_0 - __v_3);
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
-            let __ret: [G; OUT_87] = [__v_7];
-            if let Some(result) = record.function_queries[87].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_90] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[90].weight(); } record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -8183,18 +8792,19 @@ fn aiur_fn_87(
   })
 }
 
-const INPUT_SIZE_88: usize = 1;
-const IN_88: usize = 1;
-const OUT_88: usize = 63;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_91: usize = 1;
+const IN_91: usize = 1;
+const OUT_91: usize = 63;
+fn aiur_fn_91(
+  inp: [G; IN_91],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
@@ -8205,7 +8815,7 @@ fn aiur_fn_88(
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
     let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -8216,7 +8826,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_78] = { let __args: [G; IN_78] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -8227,7 +8837,7 @@ fn aiur_fn_88(
     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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -8238,29 +8848,29 @@ fn aiur_fn_88(
     let __v_38: G = __r_arr[7];
     let __v_39: G = __r_arr[8];
     let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
     let __v_44: G = __r_arr[1];
-    let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_44, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
     let __v_46: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
-    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_48, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
-    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_52, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; 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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
     let __v_54: G = __r_arr[1];
     let __v_55: G = G::from_u64(0);
-    let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
     let __v_57: G = G::from_bool((__v_56 == G::ZERO));
     let __v_58: G = (__v_56 + __v_57);
@@ -8435,22 +9045,23 @@ fn aiur_fn_88(
     if (__v_195 != __v_196) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
     }
-    let __ret: [G; OUT_88] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54];
-    if let Some(result) = record.function_queries[88].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_91] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54];
+    if !unconstrained { record.virt += record.function_queries[91].weight(); } record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_89: usize = 57;
-const IN_89: usize = 57;
-const OUT_89: usize = 1;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+const INPUT_SIZE_92: usize = 57;
+const IN_92: usize = 57;
+const OUT_92: usize = 1;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_89], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -8515,45 +9126,46 @@ fn aiur_fn_89(
     let __v_61: G = G::from_u64(0);
     let __v_62: G = G::from_u64(0);
     let __v_63: G = G::from_u64(0);
-    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_89] = [__v_70];
-    if let Some(result) = record.function_queries[89].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_92] = [__v_70];
+    if !unconstrained { record.virt += record.function_queries[92].weight(); } record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_90: usize = 2;
-const IN_90: usize = 2;
-const OUT_90: usize = 3;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+const INPUT_SIZE_93: usize = 2;
+const IN_93: usize = 2;
+const OUT_93: usize = 3;
+fn aiur_fn_93(
+  inp: [G; IN_93],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
+) -> Result<[G; OUT_93], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_4, __v_7, __v_0];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_93] = [__v_4, __v_7, __v_0];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -8564,7 +9176,7 @@ fn aiur_fn_90(
         let __v_9: G = __r_arr[7];
         let __v_10: G = __r_arr[8];
         let __v_11: G = __r_arr[9];
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
         let __v_14: G = __r_arr[2];
@@ -8575,7 +9187,7 @@ fn aiur_fn_90(
         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_78] = { let __args: [G; IN_78] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_78(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_78] = unsafe { *(result.output.as_ptr() as *const [G; OUT_78]) }; __ret } } else { aiur_fn_78(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; 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 { let __r = record.function_queries[81].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
         let __v_24: G = __r_arr[2];
@@ -8586,7 +9198,7 @@ fn aiur_fn_90(
         let __v_29: G = __r_arr[7];
         let __v_30: G = __r_arr[8];
         let __v_31: G = __r_arr[9];
-        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
         let __v_33: G = __r_arr[1];
         let __v_34: G = __r_arr[2];
@@ -8597,29 +9209,29 @@ fn aiur_fn_90(
         let __v_39: G = __r_arr[7];
         let __v_40: G = __r_arr[8];
         let __v_41: G = __r_arr[9];
-        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_75(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } } else { aiur_fn_75(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; 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 { let __r = record.function_queries[78].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
         let __v_43: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
         let __v_45: G = __r_arr[1];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_45, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_83(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } } else { aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; 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 { let __r = record.function_queries[86].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
         let __v_47: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
         let __v_49: G = __r_arr[1];
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_49, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_84(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_84] = unsafe { *(result.output.as_ptr() as *const [G; OUT_84]) }; __ret } } else { aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; 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 { let __r = record.function_queries[87].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
         let __v_51: G = __r_arr[1];
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; 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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
         let __v_53: G = __r_arr[1];
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_53, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_86(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } } else { aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; 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 { let __r = record.function_queries[89].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
         let __v_55: G = __r_arr[1];
         let __v_56: G = G::from_u64(0);
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_87(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } } else { aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; 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 { let __r = record.function_queries[90].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
         let __v_58: G = G::from_bool((__v_57 == G::ZERO));
         let __v_59: G = (__v_57 + __v_58);
@@ -8796,12 +9408,12 @@ fn aiur_fn_90(
         }
         let __v_198: G = G::from_u64(1);
         let __v_199: G = (__v_1 - __v_198);
-        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_55, __v_199]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_200: G = __r_arr[0];
         let __v_201: G = __r_arr[1];
         let __v_202: G = __r_arr[2];
         let __v_203: G = G::from_u64(0);
-        let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
         let __v_205: G = G::from_u64(0);
         let __v_206: G = G::from_u64(0);
         let __v_207: G = G::from_u64(0);
@@ -8809,87 +9421,89 @@ fn aiur_fn_90(
         let __v_209: G = G::from_u64(0);
         let __v_210: G = G::from_u64(0);
         let __v_211: G = G::from_u64(0);
-        let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_204, __v_218, __v_202];
-        if let Some(result) = record.function_queries[90].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_93] = [__v_204, __v_218, __v_202];
+        if !unconstrained { record.virt += record.function_queries[93].weight(); } record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_91: usize = 1;
-const IN_91: usize = 1;
-const OUT_91: usize = 3;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 3;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
+) -> Result<[G; OUT_94], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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(0);
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_91] = [__v_3, __v_4, __v_2];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_94] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_82(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } } else { aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; 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 { let __r = record.function_queries[85].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         let __v_7: G = G::from_u64(1);
-        let __ret: [G; OUT_91] = [__v_7, __v_5, __v_6];
-        if let Some(result) = record.function_queries[91].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_94] = [__v_7, __v_5, __v_6];
+        if !unconstrained { record.virt += record.function_queries[94].weight(); } record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_92: usize = 2;
-const IN_92: usize = 2;
-const OUT_92: usize = 2;
-fn aiur_fn_92(
-  inp: [G; IN_92],
+const INPUT_SIZE_95: usize = 2;
+const IN_95: usize = 2;
+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_92], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_92] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_95] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[76].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_76(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_76] = unsafe { *(result.output.as_ptr() as *const [G; OUT_76]) }; __ret } } else { aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_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 { let __r = record.function_queries[79].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
         let __v_5: G = (__v_1 - __v_4);
-        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
@@ -8897,17 +9511,17 @@ fn aiur_fn_92(
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_92] = [__v_11, __v_7];
-            if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_95] = [__v_11, __v_7];
+            if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
             let __v_9: G = G::from_u64(1);
-            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_92] = [__v_10, __v_7];
-            if let Some(result) = record.function_queries[92].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_95] = [__v_10, __v_7];
+            if !unconstrained { record.virt += record.function_queries[95].weight(); } record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -8916,18 +9530,19 @@ fn aiur_fn_92(
   })
 }
 
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 9;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_96: usize = 1;
+const IN_96: usize = 1;
+const OUT_96: usize = 9;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
@@ -8938,7 +9553,7 @@ fn aiur_fn_93(
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
     let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -8949,7 +9564,7 @@ fn aiur_fn_93(
     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_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -8960,7 +9575,7 @@ fn aiur_fn_93(
     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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -8971,7 +9586,7 @@ fn aiur_fn_93(
     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_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -8982,7 +9597,7 @@ fn aiur_fn_93(
     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_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -8993,7 +9608,7 @@ fn aiur_fn_93(
     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_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
@@ -9013,32 +9628,33 @@ fn aiur_fn_93(
     let __v_77: G = G::from_u64(0);
     let __v_78: G = G::from_u64(1);
     let __v_79: G = G::from_u64(1);
-    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_93] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
-    if let Some(result) = record.function_queries[93].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_96] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70];
+    if !unconstrained { record.virt += record.function_queries[96].weight(); } record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 13;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_97: usize = 1;
+const IN_97: usize = 1;
+const OUT_97: usize = 13;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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];
@@ -9049,7 +9665,7 @@ fn aiur_fn_94(
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
     let __v_10: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -9060,7 +9676,7 @@ fn aiur_fn_94(
     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_77] = { let __args: [G; IN_77] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
     let __v_22: G = __r_arr[1];
     let __v_23: G = __r_arr[2];
@@ -9071,7 +9687,7 @@ fn aiur_fn_94(
     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_77] = { let __args: [G; IN_77] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
     let __v_32: G = __r_arr[1];
     let __v_33: G = __r_arr[2];
@@ -9082,7 +9698,7 @@ fn aiur_fn_94(
     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_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
     let __v_42: G = __r_arr[1];
     let __v_43: G = __r_arr[2];
@@ -9093,7 +9709,7 @@ fn aiur_fn_94(
     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_77] = { let __args: [G; IN_77] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -9104,7 +9720,7 @@ fn aiur_fn_94(
     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_77] = { let __args: [G; IN_77] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
     let __v_62: G = __r_arr[1];
     let __v_63: G = __r_arr[2];
@@ -9124,15 +9740,15 @@ fn aiur_fn_94(
     let __v_77: G = G::from_u64(0);
     let __v_78: G = G::from_u64(1);
     let __v_79: G = G::from_u64(1);
-    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_88: G = __r_arr[0];
     let __v_89: G = __r_arr[1];
     let __v_90: G = __r_arr[2];
@@ -9143,37 +9759,97 @@ fn aiur_fn_94(
     let __v_95: G = __r_arr[7];
     let __v_96: G = __r_arr[8];
     let __v_97: G = __r_arr[9];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_97, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
     let __v_99: G = __r_arr[1];
     let __v_100: G = __r_arr[2];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_101: G = __r_arr[0];
     let __v_102: G = __r_arr[1];
     let __v_103: G = __r_arr[2];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_103, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
     let __v_105: G = __r_arr[1];
-    let __v_106: G = G::from_u64(0);
-    let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_87, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
-    let __v_108: G = __r_arr[0];
-    let __ret: [G; OUT_94] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_108, __v_98, __v_101, __v_102, __v_104, __v_105];
-    if let Some(result) = record.function_queries[94].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_106: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_106.as_canonical_u64().to_le_bytes();
+    let __v_107: G = G::from_u8(__gb[0]);
+    let __v_108: G = G::from_u8(__gb[1]);
+    let __v_109: G = G::from_u8(__gb[2]);
+    let __v_110: G = G::from_u8(__gb[3]);
+    let __v_111: G = G::from_u8(__gb[4]);
+    let __v_112: G = G::from_u8(__gb[5]);
+    let __v_113: G = G::from_u8(__gb[6]);
+    let __v_114: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_107; let __vj = __v_108; 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_109; let __vj = __v_110; 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_111; let __vj = __v_112; 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_113; let __vj = __v_114; 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_115: G = G::from_u64(1020);
+    let __v_116: G = (__v_114 - __v_115);
+    let __v_117: G = (__v_113 + __v_116);
+    let __v_118: G = (__v_112 + __v_117);
+    let __v_119: G = (__v_111 + __v_118);
+    let __v_120: G = G::from_bool((__v_119 == G::ZERO));
+    let __v_121: G = (__v_109 + __v_110);
+    let __v_122: G = (__v_108 + __v_121);
+    let __v_123: G = (__v_107 + __v_122);
+    let __v_124: G = G::from_bool((__v_123 == G::ZERO));
+    let __v_125: G = G::from_u64(256);
+    let __v_126: G = (__v_125 * __v_108);
+    let __v_127: G = G::from_u64(65536);
+    let __v_128: G = (__v_127 * __v_109);
+    let __v_129: G = G::from_u64(16777216);
+    let __v_130: G = (__v_129 * __v_110);
+    let __v_131: G = G::from_u64(4294967296);
+    let __v_132: G = (__v_131 * __v_111);
+    let __v_133: G = G::from_u64(1099511627776);
+    let __v_134: G = (__v_133 * __v_112);
+    let __v_135: G = G::from_u64(281474976710656);
+    let __v_136: G = (__v_135 * __v_113);
+    let __v_137: G = G::from_u64(72057594037927936);
+    let __v_138: G = (__v_137 * __v_114);
+    let __v_139: G = (__v_136 + __v_138);
+    let __v_140: G = (__v_134 + __v_139);
+    let __v_141: G = (__v_132 + __v_140);
+    let __v_142: G = (__v_130 + __v_141);
+    let __v_143: G = (__v_128 + __v_142);
+    let __v_144: G = (__v_126 + __v_143);
+    let __v_145: G = (__v_107 + __v_144);
+    if (__v_145 != __v_106) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_145.as_canonical_u64(), rhs: __v_106.as_canonical_u64(), msg: None });
+    }
+    let __v_146: G = G::from_u64(1);
+    let __v_147: G = G::from_u64(1);
+    let __v_148: G = (__v_147 - __v_124);
+    let __v_149: G = (__v_120 * __v_148);
+    let __v_150: G = (__v_146 - __v_149);
+    let __v_151: G = G::from_u64(1);
+    if (__v_150 != __v_151) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_151.as_canonical_u64(), msg: None });
+    }
+    let __v_152: G = G::from_u64(0);
+    let __v_153: G = G::from_u64(0);
+    let __v_154: G = { let __values: [G; 10] = [__v_153, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_155: G = { let __values: [G; 10] = [__v_152, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_154]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_87, __v_155]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+    let __ret: [G; OUT_97] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_156, __v_98, __v_101, __v_102, __v_104, __v_105];
+    if !unconstrained { record.virt += record.function_queries[97].weight(); } record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 5;
-const IN_95: usize = 5;
-const OUT_95: usize = 1;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+const INPUT_SIZE_98: usize = 5;
+const IN_98: usize = 5;
+const OUT_98: usize = 1;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_95], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9183,26 +9859,27 @@ fn aiur_fn_95(
     let __v_6: G = G::from_u64(0);
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(0);
-    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_95] = [__v_12];
-    if let Some(result) = record.function_queries[95].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_98] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[98].weight(); } record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_96: usize = 33;
-const IN_96: usize = 33;
-const OUT_96: usize = 1;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_99: usize = 33;
+const IN_99: usize = 33;
+const OUT_99: usize = 1;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9236,38 +9913,39 @@ fn aiur_fn_96(
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
     let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_36: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
-    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
     let __v_40: G = __r_arr[0];
-    let __ret: [G; OUT_96] = [__v_40];
-    if let Some(result) = record.function_queries[96].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_99] = [__v_40];
+    if !unconstrained { record.virt += record.function_queries[99].weight(); } record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_97: usize = 32;
-const IN_97: usize = 32;
-const OUT_97: usize = 32;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_100: usize = 32;
+const IN_100: usize = 32;
+const OUT_100: usize = 32;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -9300,22 +9978,23 @@ fn aiur_fn_97(
     let __v_29: G = inp[29];
     let __v_30: G = inp[30];
     let __v_31: G = inp[31];
-    let __ret: [G; OUT_97] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31];
-    if let Some(result) = record.function_queries[97].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31];
+    if !unconstrained { record.virt += record.function_queries[100].weight(); } record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 2;
-const IN_98: usize = 2;
-const OUT_98: usize = 1;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_101: usize = 2;
+const IN_101: usize = 2;
+const OUT_101: usize = 1;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(103);
@@ -9350,7 +10029,7 @@ fn aiur_fn_98(
     let __v_31: G = G::from_u64(205);
     let __v_32: G = G::from_u64(224);
     let __v_33: G = G::from_u64(91);
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_34: G = __loaded[0];
     let __v_35: G = __loaded[1];
     let __v_36: G = __loaded[2];
@@ -9383,7 +10062,7 @@ fn aiur_fn_98(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_66: G = __loaded[0];
     let __v_67: G = __loaded[1];
     let __v_68: G = __loaded[2];
@@ -9449,7 +10128,7 @@ fn aiur_fn_98(
     let __v_128: G = G::from_u64(0);
     let __v_129: G = G::from_u64(0);
     let __v_130: G = G::from_u64(0);
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_131: G = __r_arr[0];
     let __v_132: G = __r_arr[1];
     let __v_133: G = __r_arr[2];
@@ -9482,66 +10161,68 @@ fn aiur_fn_98(
     let __v_160: G = __r_arr[29];
     let __v_161: G = __r_arr[30];
     let __v_162: G = __r_arr[31];
-    let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_98] = [__v_163];
-    if let Some(result) = record.function_queries[98].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_101] = [__v_163];
+    if !unconstrained { record.virt += record.function_queries[101].weight(); } record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 3;
-const IN_99: usize = 3;
-const OUT_99: usize = 1;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_102: usize = 3;
+const IN_102: usize = 3;
+const OUT_102: usize = 1;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_99] = [__v_3];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_102] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_99] = [__v_3];
-        if let Some(result) = record.function_queries[99].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_102] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[102].weight(); } record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_100: usize = 2;
-const IN_100: usize = 2;
-const OUT_100: usize = 1;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_103: usize = 2;
+const IN_103: usize = 2;
+const OUT_103: usize = 1;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_100] = [__v_5];
-        if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_103] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
@@ -9550,15 +10231,15 @@ fn aiur_fn_100(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_100] = [__v_7];
-            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_103] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_100] = [__v_7];
-            if let Some(result) = record.function_queries[100].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_103] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[103].weight(); } record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -9570,20 +10251,21 @@ fn aiur_fn_100(
   })
 }
 
-const INPUT_SIZE_101: usize = 3;
-const IN_101: usize = 3;
-const OUT_101: usize = 1;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_104: usize = 3;
+const IN_104: usize = 3;
+const OUT_104: usize = 1;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -9591,13 +10273,13 @@ fn aiur_fn_101(
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_101] = [__v_8];
-        if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_104] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
         let __v_7: G = __loaded[1];
         let __v_8: G = __loaded[2];
@@ -9607,14 +10289,14 @@ fn aiur_fn_101(
             let __v_10: G = G::from_bool((__v_9 == G::ZERO));
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
-                let __ret: [G; OUT_101] = [__v_11];
-                if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_104] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
-                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+                let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
                 let __v_11: G = __loaded[0];
                 let __v_12: G = __loaded[1];
                 let __v_13: G = __loaded[2];
@@ -9627,19 +10309,19 @@ fn aiur_fn_101(
                 let __v_20: G = __loaded[9];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
-                    let __ret: [G; OUT_101] = [__v_21];
-                    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_104] = [__v_21];
+                    if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_21: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
-                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_101] = [__v_23];
-                    if let Some(result) = record.function_queries[101].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __ret: [G; OUT_104] = [__v_23];
+                    if !unconstrained { record.virt += record.function_queries[104].weight(); } record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
@@ -9658,19 +10340,20 @@ fn aiur_fn_101(
   })
 }
 
-const INPUT_SIZE_102: usize = 2;
-const IN_102: usize = 2;
-const OUT_102: usize = 11;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_105: usize = 2;
+const IN_105: usize = 2;
+const OUT_105: usize = 11;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -9761,12 +10444,12 @@ fn aiur_fn_102(
           return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
         }
         let __v_78: G = G::from_u64(1);
-        let __ret: [G; OUT_102] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
-        if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_105] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78];
+        if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_12: G = __loaded[0];
         let __v_13: G = __loaded[1];
         let __v_14: G = __loaded[2];
@@ -9781,12 +10464,12 @@ fn aiur_fn_102(
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
             let __v_23: G = G::from_u64(0);
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23];
+            if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_13, __v_14]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
             let __v_17: G = __r_arr[2];
@@ -9798,8 +10481,8 @@ fn aiur_fn_102(
             let __v_23: G = __r_arr[8];
             let __v_24: G = __r_arr[9];
             let __v_25: G = __r_arr[10];
-            let __ret: [G; OUT_102] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-            if let Some(result) = record.function_queries[102].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+            if !unconstrained { record.virt += record.function_queries[105].weight(); } record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -9814,23 +10497,24 @@ fn aiur_fn_102(
   })
 }
 
-const INPUT_SIZE_103: usize = 6;
-const IN_103: usize = 6;
-const OUT_103: usize = 1;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_106: usize = 6;
+const IN_106: usize = 6;
+const OUT_106: usize = 1;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_102] = { let __args: [G; IN_102] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     let __v_8: G = __r_arr[2];
@@ -9844,7 +10528,7 @@ fn aiur_fn_103(
     let __v_16: G = __r_arr[10];
     match __v_16.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
         let __v_18: G = __loaded[1];
         let __v_19: G = __loaded[2];
@@ -9869,7 +10553,7 @@ fn aiur_fn_103(
                                   0u64 => {
                                     match __v_24.as_canonical_u64() {
                                       0u64 => {
-                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
                                         let __v_25: G = __loaded[0];
                                         let __v_26: G = __loaded[1];
                                         let __v_27: G = __loaded[2];
@@ -9966,7 +10650,7 @@ fn aiur_fn_103(
                                         let __v_118: G = G::from_u64(0);
                                         let __v_119: G = G::from_u64(0);
                                         let __v_120: G = G::from_u64(0);
-                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                                        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
                                         let __v_121: G = __loaded[0];
                                         let __v_122: G = __loaded[1];
                                         let __v_123: G = __loaded[2];
@@ -10001,7 +10685,7 @@ fn aiur_fn_103(
                                         let __v_152: G = G::from_u64(0);
                                         let __v_153: G = G::from_u64(0);
                                         let __v_154: G = G::from_u64(0);
-                                        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_155: G = __r_arr[0];
                                         let __v_156: G = __r_arr[1];
                                         let __v_157: G = __r_arr[2];
@@ -10034,69 +10718,69 @@ fn aiur_fn_103(
                                         let __v_184: G = __r_arr[29];
                                         let __v_185: G = __r_arr[30];
                                         let __v_186: G = __r_arr[31];
-                                        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_103] = [__v_187];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                        let __ret: [G; OUT_106] = [__v_187];
+                                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __ret: [G; OUT_103] = [__v_5];
-                                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                        let __ret: [G; OUT_106] = [__v_5];
+                                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                         return Ok(__ret);
                                       },
                                     }
                                   },
                                   _ => {
-                                    let __ret: [G; OUT_103] = [__v_5];
-                                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                    let __ret: [G; OUT_106] = [__v_5];
+                                    if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                     return Ok(__ret);
                                   },
                                 }
                               },
                               _ => {
-                                let __ret: [G; OUT_103] = [__v_5];
-                                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                                let __ret: [G; OUT_106] = [__v_5];
+                                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
-                            let __ret: [G; OUT_103] = [__v_5];
-                            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                            let __ret: [G; OUT_106] = [__v_5];
+                            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        let __ret: [G; OUT_103] = [__v_5];
-                        if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                        let __ret: [G; OUT_106] = [__v_5];
+                        if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __ret: [G; OUT_103] = [__v_5];
-                    if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                    let __ret: [G; OUT_106] = [__v_5];
+                    if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_103] = [__v_5];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_106] = [__v_5];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_103] = [__v_5];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_106] = [__v_5];
+            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14, __v_15]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
         let __v_18: G = __r_arr[1];
         let __v_19: G = __r_arr[2];
@@ -10108,7 +10792,7 @@ fn aiur_fn_103(
         let __v_25: G = __r_arr[8];
         let __v_26: G = __r_arr[9];
         let __v_27: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_25, __v_26]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
         let __v_30: G = __r_arr[2];
@@ -10120,7 +10804,7 @@ fn aiur_fn_103(
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
         let __v_38: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_36, __v_37]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
         let __v_40: G = __r_arr[1];
         let __v_41: G = __r_arr[2];
@@ -10132,7 +10816,7 @@ fn aiur_fn_103(
         let __v_47: G = __r_arr[8];
         let __v_48: G = __r_arr[9];
         let __v_49: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
         let __v_51: G = __r_arr[1];
         let __v_52: G = __r_arr[2];
@@ -10144,7 +10828,7 @@ fn aiur_fn_103(
         let __v_58: G = __r_arr[8];
         let __v_59: G = __r_arr[9];
         let __v_60: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_58, __v_59]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
         let __v_62: G = __r_arr[1];
         let __v_63: G = __r_arr[2];
@@ -10156,7 +10840,7 @@ fn aiur_fn_103(
         let __v_69: G = __r_arr[8];
         let __v_70: G = __r_arr[9];
         let __v_71: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_69, __v_70]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
         let __v_73: G = __r_arr[1];
         let __v_74: G = __r_arr[2];
@@ -10168,7 +10852,7 @@ fn aiur_fn_103(
         let __v_80: G = __r_arr[8];
         let __v_81: G = __r_arr[9];
         let __v_82: G = __r_arr[10];
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_102(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } } else { aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_80, __v_81]; 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 { let __r = record.function_queries[105].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
         let __v_84: G = __r_arr[1];
         let __v_85: G = __r_arr[2];
@@ -10189,7 +10873,7 @@ fn aiur_fn_103(
         let __v_100: G = (__v_27 + __v_99);
         let __v_101: G = (__v_16 + __v_100);
         let __v_102: G = (__v_94 * __v_101);
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_103: G = __loaded[0];
         let __v_104: G = __loaded[1];
         let __v_105: G = __loaded[2];
@@ -10202,7 +10886,7 @@ fn aiur_fn_103(
         let __v_112: G = __loaded[9];
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() {
   1u64 => {
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_113: G = __loaded[0];
     let __v_114: G = __loaded[1];
     let __v_115: G = __loaded[2];
@@ -10231,7 +10915,7 @@ fn aiur_fn_103(
         let __v_118: G = (__v_113 * __v_116);
         let __v_119: G = (__v_116 - __v_118);
         let __v_120: G = (__v_113 + __v_119);
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_121: G = __loaded[0];
         let __v_122: G = __loaded[1];
         let __v_123: G = __loaded[2];
@@ -10240,7 +10924,7 @@ fn aiur_fn_103(
         let __v_126: G = __loaded[5];
         let __v_127: G = __loaded[6];
         let __v_128: G = __loaded[7];
-        let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; 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 { let __r = record.function_queries[4].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
         let __v_130: G = (__v_113 * __v_129);
         let __v_131: G = G::from_u64(2);
@@ -10249,7 +10933,7 @@ fn aiur_fn_103(
         let __v_134: G = (__v_133 * __v_130);
         let __v_135: G = (__v_132 + __v_134);
         let __v_136: G = (__v_117 + __v_135);
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_137: G = __loaded[0];
         let __v_138: G = __loaded[1];
         let __v_139: G = __loaded[2];
@@ -10282,7 +10966,7 @@ fn aiur_fn_103(
         let __v_166: G = __loaded[29];
         let __v_167: G = __loaded[30];
         let __v_168: G = __loaded[31];
-        let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_169: G = __loaded[0];
         let __v_170: G = __loaded[1];
         let __v_171: G = __loaded[2];
@@ -10314,7 +10998,7 @@ fn aiur_fn_103(
         let __v_197: G = G::from_u64(0);
         let __v_198: G = G::from_u64(0);
         let __v_199: G = G::from_u64(0);
-        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_73(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } } else { aiur_fn_73(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; 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 { let __r = record.function_queries[76].replay_at(__i); record.virt += __r; } 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_200: G = __r_arr[0];
         let __v_201: G = __r_arr[1];
         let __v_202: G = __r_arr[2];
@@ -10350,9 +11034,9 @@ fn aiur_fn_103(
         match __v_113.as_canonical_u64() {
           1u64 => {
             let __v_232: G = G::from_u64(0);
-            let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_103] = [__v_233];
-            if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_106] = [__v_233];
+            if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -10391,7 +11075,7 @@ fn aiur_fn_103(
                 let __v_262: G = G::from_u64(224);
                 let __v_263: G = G::from_u64(91);
                 let __v_264: G = G::from_u64(0);
-                let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+                let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
                 let __v_265: G = __loaded[0];
                 let __v_266: G = __loaded[1];
                 let __v_267: G = __loaded[2];
@@ -10400,7 +11084,7 @@ fn aiur_fn_103(
                 let __v_270: G = __loaded[5];
                 let __v_271: G = __loaded[6];
                 let __v_272: G = __loaded[7];
-                let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_9(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } } else { aiur_fn_9(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[12].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } };
                 let __v_273: G = __r_arr[0];
                 let __v_274: G = __r_arr[1];
                 let __v_275: G = __r_arr[2];
@@ -10409,24 +11093,24 @@ fn aiur_fn_103(
                 let __v_278: G = __r_arr[5];
                 let __v_279: G = __r_arr[6];
                 let __v_280: G = __r_arr[7];
-                let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_282: G = { let __values: [G; 32] = [__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, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+                let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_282: G = { let __values: [G; 32] = [__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, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
                 let __v_283: G = G::from_u64(0);
-                let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+                let __v_284: G = { let __values: [G; 34] = [__v_283, __v_5, __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]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_285: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_285];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_106] = [__v_285];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
               _ => {
                 let __v_232: G = G::from_u64(1);
                 let __v_233: G = (__v_2 + __v_232);
-                let __v_234: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+                let __v_234: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_235: G = __r_arr[0];
-                let __ret: [G; OUT_103] = [__v_235];
-                if let Some(result) = record.function_queries[103].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+                let __ret: [G; OUT_106] = [__v_235];
+                if !unconstrained { record.virt += record.function_queries[106].weight(); } record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
                 return Ok(__ret);
               },
             }
@@ -10437,16 +11121,17 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 32;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 32;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(103);
     let __v_2: G = G::from_u64(230);
@@ -10482,7 +11167,7 @@ fn aiur_fn_104(
     let __v_32: G = G::from_u64(91);
     let __v_33: G = G::from_u64(1);
     let __v_34: G = G::from_u64(1);
-    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_36: G = G::from_u64(0);
     let __v_37: G = G::from_u64(0);
     let __v_38: G = G::from_u64(0);
@@ -10492,14 +11177,14 @@ fn aiur_fn_104(
     let __v_42: G = G::from_u64(0);
     let __v_43: G = G::from_u64(0);
     let __v_44: G = G::from_u64(0);
-    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_47: G = G::from_u64(1);
     let __v_48: G = G::from_u64(1);
-    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+    let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; 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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
     let __v_52: G = __r_arr[1];
     let __v_53: G = __r_arr[2];
@@ -10532,26 +11217,27 @@ fn aiur_fn_104(
     let __v_80: G = __r_arr[29];
     let __v_81: G = __r_arr[30];
     let __v_82: G = __r_arr[31];
-    let __ret: [G; OUT_104] = [__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];
-    if let Some(result) = record.function_queries[104].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __ret: [G; OUT_107] = [__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];
+    if !unconstrained { record.virt += record.function_queries[107].weight(); } record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 3;
-const IN_105: usize = 3;
-const OUT_105: usize = 1;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_108: usize = 3;
+const IN_108: usize = 3;
+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_105], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_101(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } } else { aiur_fn_101(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[104].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(103);
     let __v_5: G = G::from_u64(230);
@@ -10587,7 +11273,7 @@ fn aiur_fn_105(
     let __v_35: G = G::from_u64(91);
     let __v_36: G = G::from_u64(1);
     let __v_37: G = G::from_u64(1);
-    let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_39: G = G::from_u64(0);
     let __v_40: G = G::from_u64(0);
     let __v_41: G = G::from_u64(0);
@@ -10597,14 +11283,14 @@ fn aiur_fn_105(
     let __v_45: G = G::from_u64(0);
     let __v_46: G = G::from_u64(0);
     let __v_47: G = G::from_u64(0);
-    let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_50: G = G::from_u64(1);
     let __v_51: G = G::from_u64(1);
-    let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_103(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } } else { aiur_fn_103(__args, record, io_buffer, __cu)? } };
+    let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_38, __v_3, __v_39, __v_48, __v_49, __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 { let __r = record.function_queries[106].replay_at(__i); record.virt += __r; } 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 __v_53: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_54: G = __r_arr[0];
     let __v_55: G = __r_arr[1];
     let __v_56: G = __r_arr[2];
@@ -10637,78 +11323,80 @@ fn aiur_fn_105(
     let __v_83: G = __r_arr[29];
     let __v_84: G = __r_arr[30];
     let __v_85: G = __r_arr[31];
-    let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_105] = [__v_86];
-    if let Some(result) = record.function_queries[105].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_108] = [__v_86];
+    if !unconstrained { record.virt += record.function_queries[108].weight(); } record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_106: usize = 4;
-const IN_106: usize = 4;
-const OUT_106: usize = 1;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_109: usize = 4;
+const IN_109: usize = 4;
+const OUT_109: usize = 1;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __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_100] = { let __args: [G; IN_100] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __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 { let __r = record.function_queries[103].replay_at(__i); record.virt += __r; } 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 __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_106] = [__v_3];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __ret: [G; OUT_106] = [__v_6];
-        if let Some(result) = record.function_queries[106].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_109] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[109].weight(); } record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 1;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 1;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_107] = [__v_4];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
         let __v_6: G = (__v_4 * __v_5);
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_107] = [__v_7];
-        if let Some(result) = record.function_queries[107].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_110] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[110].weight(); } record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -10718,386 +11406,318 @@ fn aiur_fn_107(
   })
 }
 
-const INPUT_SIZE_108: usize = 6;
-const IN_108: usize = 6;
-const OUT_108: usize = 2;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_111: usize = 2;
+const IN_111: usize = 2;
+const OUT_111: usize = 1;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    match __v_6.as_canonical_u64() {
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_108] = [__v_0, __v_9];
-        if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_111] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_9: G = __loaded[0];
-        let __v_10: G = __loaded[1];
-        let __v_11: G = __loaded[2];
-        match __v_9.as_canonical_u64() {
-          0u64 => {
-            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
-  0u64 => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_7, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    break '__mc_0 [__v_12];
-  },
-}
- };
-            let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_100(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } } else { aiur_fn_100(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_13.as_canonical_u64() {
-  0u64 => {
-    break '__mc_1 [__v_12];
-  },
-  _ => {
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_98(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } } else { aiur_fn_98(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    break '__mc_1 [__v_15];
-  },
-}
- };
-            let __v_14: G = __mc_out___mc_1[0];
-            let __v_15: G = G::from_u64(1);
-            let __v_16: G = (__v_5 - __v_15);
-            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_14, __v_1, __v_2, __v_8, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_108] = [__v_17, __v_18];
-            if let Some(result) = record.function_queries[108].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = __loaded[3];
+        let __v_12: G = __loaded[4];
+        let __v_13: G = __loaded[5];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_111] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
+          0u64 => {
+            match __v_3.as_canonical_u64() {
+              _ => {
+                match __v_9.as_canonical_u64() {
+                  _ => {
+                    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; 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 { let __r = record.function_queries[0].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+                    match __v_14.as_canonical_u64() {
+                      1u64 => {
+                        let __v_15: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7, __v_1]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+                        let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_111] = [__v_17];
+                        if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_15: G = (__v_3 - __v_9);
+                        let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+                        match __v_16.as_canonical_u64() {
+                          1u64 => {
+                            if (__v_6 != __v_12) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+                            }
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7, __v_13]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __ret: [G; OUT_111] = [__v_19];
+                            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_17: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                            let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __ret: [G; OUT_111] = [__v_19];
+                            if !unconstrained { record.virt += record.function_queries[111].weight(); } record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_109: usize = 5;
-const IN_109: usize = 5;
-const OUT_109: usize = 2;
-fn aiur_fn_109(
-  inp: [G; IN_109],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __v_6: G = G::from_u64(1);
-    let __v_7: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_5, __v_0, __v_1, __v_3, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_109] = [__v_8, __v_9];
-    if let Some(result) = record.function_queries[109].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_110: usize = 6;
-const IN_110: usize = 6;
-const OUT_110: usize = 1;
-fn aiur_fn_110(
-  inp: [G; IN_110],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_105(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } } else { aiur_fn_105(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __v_7: G = G::from_u64(1);
-    let __v_8: G = (__v_5 - __v_7);
-    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_6, __v_1, __v_2, __v_4, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_108(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } } else { aiur_fn_108(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = __r_arr[1];
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = (__v_11 - __v_9);
-    let __v_13: G = G::from_bool((__v_12 == G::ZERO));
-    let __ret: [G; OUT_110] = [__v_13];
-    if let Some(result) = record.function_queries[110].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_111: usize = 2;
-const IN_111: usize = 2;
-const OUT_111: usize = 1;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 2;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_111] = [__v_1];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_112] = [__v_9, __v_12];
+        if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-        let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_111] = [__v_7];
-        if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(1);
+            let __v_15: G = G::from_u64(1);
+            let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_18: G = G::from_u64(1);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_112] = [__v_17, __v_20];
+            if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_112] = [__v_16, __v_18];
+            if !unconstrained { record.virt += record.function_queries[112].weight(); } record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 1;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 1;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_112] = [__v_5];
-        if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_113] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = (__v_0 * __v_0);
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        match __v_3.as_canonical_u64() {
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        match __v_7.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_113] = [__v_0];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
           0u64 => {
-            let __ret: [G; OUT_112] = [__v_6];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0]; 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 { let __r = record.function_queries[112].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = __r_arr[1];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_13]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+            let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_14]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+            let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_15, __v_16]; 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 { let __r = record.function_queries[111].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __ret: [G; OUT_113] = [__v_17];
+            if !unconstrained { record.virt += record.function_queries[113].weight(); } record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __v_7: G = (__v_0 * __v_6);
-            let __ret: [G; OUT_112] = [__v_7];
-            if let Some(result) = record.function_queries[112].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_113: usize = 8;
-const IN_113: usize = 8;
-const OUT_113: usize = 2;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_114: usize = 4;
+const IN_114: usize = 4;
+const OUT_114: usize = 1;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = G::from_u64(1);
-    let __v_9: G = (__v_1 + __v_8);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __v_11: G = G::from_u64(1);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = (__v_15 + __v_15);
-    let __v_17: G = (__v_4 + __v_6);
-    let __v_18: G = (__v_5 + __v_7);
-    let __v_19: G = G::from_u64(2);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = (__v_19 * __v_19);
-    let __v_22: G = G::from_u64(7);
-    let __v_23: G = (__v_20 * __v_20);
-    let __v_24: G = (__v_22 * __v_23);
-    let __v_25: G = (__v_21 - __v_24);
-    let __v_26: G = g_inverse_value(__v_25);
-    let __v_27: G = (__v_25 * __v_26);
-    let __v_28: G = G::from_u64(1);
-    let __v_29: G = (__v_27 - __v_28);
-    let __v_30: G = (__v_25 * __v_29);
-    let __v_31: G = G::from_u64(0);
-    if (__v_30 != __v_31) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
-    }
-    let __v_32: G = (__v_26 * __v_29);
-    let __v_33: G = G::from_u64(0);
-    if (__v_32 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
-    }
-    let __v_34: G = (__v_19 * __v_26);
-    let __v_35: G = G::from_u64(0);
-    let __v_36: G = (__v_35 - __v_20);
-    let __v_37: G = (__v_36 * __v_26);
-    let __v_38: G = (__v_17 * __v_34);
-    let __v_39: G = G::from_u64(7);
-    let __v_40: G = (__v_18 * __v_37);
-    let __v_41: G = (__v_39 * __v_40);
-    let __v_42: G = (__v_38 + __v_41);
-    let __v_43: G = (__v_17 * __v_37);
-    let __v_44: G = (__v_18 * __v_34);
-    let __v_45: G = (__v_43 + __v_44);
-    let __v_46: G = (__v_4 - __v_6);
-    let __v_47: G = (__v_5 - __v_7);
-    let __v_48: G = G::from_u64(0);
-    let __v_49: G = (__v_16 * __v_16);
-    let __v_50: G = G::from_u64(7);
-    let __v_51: G = (__v_48 * __v_48);
-    let __v_52: G = (__v_50 * __v_51);
-    let __v_53: G = (__v_49 - __v_52);
-    let __v_54: G = g_inverse_value(__v_53);
-    let __v_55: G = (__v_53 * __v_54);
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = (__v_55 - __v_56);
-    let __v_58: G = (__v_53 * __v_57);
-    let __v_59: G = G::from_u64(0);
-    if (__v_58 != __v_59) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
-    }
-    let __v_60: G = (__v_54 * __v_57);
-    let __v_61: G = G::from_u64(0);
-    if (__v_60 != __v_61) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+        let __v_8: G = G::from_u64(0);
+        if (__v_7 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+        }
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_114] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        match __v_7.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_8, __v_2, __v_3]; 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 { let __r = record.function_queries[108].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+            let __v_11: G = G::from_u64(0);
+            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_5]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+            let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6, __v_9, __v_2, __v_3]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_114] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[114].weight(); } record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
     }
-    let __v_62: G = (__v_16 * __v_54);
-    let __v_63: G = G::from_u64(0);
-    let __v_64: G = (__v_63 - __v_48);
-    let __v_65: G = (__v_64 * __v_54);
-    let __v_66: G = (__v_46 * __v_62);
-    let __v_67: G = G::from_u64(7);
-    let __v_68: G = (__v_47 * __v_65);
-    let __v_69: G = (__v_67 * __v_68);
-    let __v_70: G = (__v_66 + __v_69);
-    let __v_71: G = (__v_46 * __v_65);
-    let __v_72: G = (__v_47 * __v_62);
-    let __v_73: G = (__v_71 + __v_72);
-    let __v_74: G = (__v_2 * __v_70);
-    let __v_75: G = G::from_u64(7);
-    let __v_76: G = (__v_3 * __v_73);
-    let __v_77: G = (__v_75 * __v_76);
-    let __v_78: G = (__v_74 + __v_77);
-    let __v_79: G = (__v_2 * __v_73);
-    let __v_80: G = (__v_3 * __v_70);
-    let __v_81: G = (__v_79 + __v_80);
-    let __v_82: G = (__v_42 + __v_78);
-    let __v_83: G = (__v_45 + __v_81);
-    let __ret: [G; OUT_113] = [__v_82, __v_83];
-    if let Some(result) = record.function_queries[113].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_114: usize = 2;
-const IN_114: usize = 2;
-const OUT_114: usize = 1;
-fn aiur_fn_114(
-  inp: [G; IN_114],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = G::from_u64(1);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_8: G = __r_arr[0];
-    let __v_9: G = (__v_2 * __v_8);
-    let __ret: [G; OUT_114] = [__v_9];
-    if let Some(result) = record.function_queries[114].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_115: usize = 8;
-const IN_115: usize = 8;
-const OUT_115: usize = 4;
+const INPUT_SIZE_115: usize = 4;
+const IN_115: usize = 4;
+const OUT_115: usize = 2;
 fn aiur_fn_115(
   inp: [G; IN_115],
   record: &mut QueryRecord,
@@ -11105,105 +11725,155 @@ fn aiur_fn_115(
   unconstrained: bool,
 ) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    let __v_15: G = __loaded[7];
-    let __v_16: G = __loaded[8];
-    let __v_17: G = __loaded[9];
-    match __v_8.as_canonical_u64() {
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_4: G = __loaded[0];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    let __v_7: G = __loaded[3];
+    let __v_8: G = __loaded[4];
+    let __v_9: G = __loaded[5];
+    match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_115] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_115] = [__v_12, __v_1];
+        if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_18: G = __loaded[0];
-        let __v_19: G = __loaded[1];
-        let __v_20: G = __loaded[2];
-        let __v_21: G = __loaded[3];
-        match __v_18.as_canonical_u64() {
-          0u64 => {
-            let __v_22: G = G::from_u64(256);
-            let __v_23: G = (__v_22 * __v_10);
-            let __v_24: G = G::from_u64(65536);
-            let __v_25: G = (__v_24 * __v_11);
-            let __v_26: G = G::from_u64(16777216);
-            let __v_27: G = (__v_26 * __v_12);
-            let __v_28: G = G::from_u64(4294967296);
-            let __v_29: G = (__v_28 * __v_13);
-            let __v_30: G = G::from_u64(1099511627776);
-            let __v_31: G = (__v_30 * __v_14);
-            let __v_32: G = G::from_u64(281474976710656);
-            let __v_33: G = (__v_32 * __v_15);
-            let __v_34: G = G::from_u64(72057594037927936);
-            let __v_35: G = (__v_34 * __v_16);
-            let __v_36: G = (__v_33 + __v_35);
-            let __v_37: G = (__v_31 + __v_36);
-            let __v_38: G = (__v_29 + __v_37);
-            let __v_39: G = (__v_27 + __v_38);
-            let __v_40: G = (__v_25 + __v_39);
-            let __v_41: G = (__v_23 + __v_40);
-            let __v_42: G = (__v_9 + __v_41);
-            let __v_43: G = G::from_u64(0);
-            let __v_44: G = (__v_19 - __v_42);
-            let __v_45: G = (__v_20 - __v_43);
-            let __v_46: G = (__v_6 * __v_44);
-            let __v_47: G = G::from_u64(7);
-            let __v_48: G = (__v_7 * __v_45);
-            let __v_49: G = (__v_47 * __v_48);
-            let __v_50: G = (__v_46 + __v_49);
-            let __v_51: G = (__v_6 * __v_45);
-            let __v_52: G = (__v_7 * __v_44);
-            let __v_53: G = (__v_51 + __v_52);
-            let __v_54: G = (__v_4 + __v_50);
-            let __v_55: G = (__v_5 + __v_53);
-            let __v_56: G = (__v_6 * __v_2);
-            let __v_57: G = G::from_u64(7);
-            let __v_58: G = (__v_7 * __v_3);
-            let __v_59: G = (__v_57 * __v_58);
-            let __v_60: G = (__v_56 + __v_59);
-            let __v_61: G = (__v_6 * __v_3);
-            let __v_62: G = (__v_7 * __v_2);
-            let __v_63: G = (__v_61 + __v_62);
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-            let __v_64: G = __r_arr[0];
-            let __v_65: G = __r_arr[1];
-            let __v_66: G = __r_arr[2];
-            let __v_67: G = __r_arr[3];
-            let __ret: [G; OUT_115] = [__v_64, __v_65, __v_66, __v_67];
-            if let Some(result) = record.function_queries[115].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
+        match __v_5.as_canonical_u64() {
           _ => {
-            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+                let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+                let __v_14: G = __loaded[0];
+                let __v_15: G = __loaded[1];
+                let __v_16: G = __loaded[2];
+                let __v_17: G = __loaded[3];
+                let __v_18: G = __loaded[4];
+                let __v_19: G = __loaded[5];
+                match __v_14.as_canonical_u64() {
+                  0u64 => {
+                    match __v_15.as_canonical_u64() {
+                      _ => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                        let __v_21: G = __loaded[1];
+                        let __v_22: G = __loaded[2];
+                        match __v_20.as_canonical_u64() {
+                          0u64 => {
+                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_22]; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+                            let __v_24: G = (__v_13 - __v_23);
+                            let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+                            match __v_25.as_canonical_u64() {
+                              1u64 => {
+                                let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; 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 { let __r = record.function_queries[101].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+                                let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_26]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+                                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_19, __v_1, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_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; 6] = [__v_30, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                let __ret: [G; OUT_115] = [__v_31, __v_29];
+                                if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_26: G = __loaded[0];
+                                let __v_27: G = __loaded[1];
+                                let __v_28: G = __loaded[2];
+                                match __v_26.as_canonical_u64() {
+                                  0u64 => {
+                                    let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; 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 { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_29]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+                                    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9, __v_28, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                                    let __v_32: G = __r_arr[1];
+                                    let __v_33: G = G::from_u64(0);
+                                    let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                    let __ret: [G; OUT_115] = [__v_34, __v_32];
+                                    if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                          },
+                        }
+                      },
+                    }
+                  },
+                  1u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
+                      0u64 => {
+                        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; 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 { let __r = record.function_queries[102].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+                        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_7, __v_2, __v_3, __v_23]; 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 { let __r = record.function_queries[109].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+                        let __v_25: G = G::from_u64(0);
+                        let __v_26: G = G::from_u64(1);
+                        let __v_27: G = G::from_u64(1);
+                        let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_115] = [__v_29, __v_22];
+                        if !unconstrained { record.virt += record.function_queries[115].weight(); } record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
           },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_116: usize = 2;
-const IN_116: usize = 2;
-const OUT_116: usize = 1;
+const INPUT_SIZE_116: usize = 4;
+const IN_116: usize = 4;
+const OUT_116: usize = 2;
 fn aiur_fn_116(
   inp: [G; IN_116],
   record: &mut QueryRecord,
@@ -11211,151 +11881,38 @@ fn aiur_fn_116(
   unconstrained: bool,
 ) -> Result<[G; OUT_116], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_116] = [__v_1];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
-        let __v_6: G = G::from_u8(__gb[0]);
-        let __v_7: G = G::from_u8(__gb[1]);
-        let __v_8: G = G::from_u8(__gb[2]);
-        let __v_9: G = G::from_u8(__gb[3]);
-        let __v_10: G = G::from_u8(__gb[4]);
-        let __v_11: G = G::from_u8(__gb[5]);
-        let __v_12: G = G::from_u8(__gb[6]);
-        let __v_13: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_14: G = G::from_u64(1020);
-        let __v_15: G = (__v_13 - __v_14);
-        let __v_16: G = (__v_12 + __v_15);
-        let __v_17: G = (__v_11 + __v_16);
-        let __v_18: G = (__v_10 + __v_17);
-        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
-        let __v_20: G = (__v_8 + __v_9);
-        let __v_21: G = (__v_7 + __v_20);
-        let __v_22: G = (__v_6 + __v_21);
-        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
-        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
-        let __v_24: G = G::from_u8(__gb[0]);
-        let __v_25: G = G::from_u8(__gb[1]);
-        let __v_26: G = G::from_u8(__gb[2]);
-        let __v_27: G = G::from_u8(__gb[3]);
-        let __v_28: G = G::from_u8(__gb[4]);
-        let __v_29: G = G::from_u8(__gb[5]);
-        let __v_30: G = G::from_u8(__gb[6]);
-        let __v_31: G = G::from_u8(__gb[7]);
-        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-        let __v_32: G = G::from_u64(1020);
-        let __v_33: G = (__v_31 - __v_32);
-        let __v_34: G = (__v_30 + __v_33);
-        let __v_35: G = (__v_29 + __v_34);
-        let __v_36: G = (__v_28 + __v_35);
-        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
-        let __v_38: G = (__v_26 + __v_27);
-        let __v_39: G = (__v_25 + __v_38);
-        let __v_40: G = (__v_24 + __v_39);
-        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
-        let __v_42: G = G::from_u64(256);
-        let __v_43: G = (__v_42 * __v_7);
-        let __v_44: G = G::from_u64(65536);
-        let __v_45: G = (__v_44 * __v_8);
-        let __v_46: G = G::from_u64(16777216);
-        let __v_47: G = (__v_46 * __v_9);
-        let __v_48: G = G::from_u64(4294967296);
-        let __v_49: G = (__v_48 * __v_10);
-        let __v_50: G = G::from_u64(1099511627776);
-        let __v_51: G = (__v_50 * __v_11);
-        let __v_52: G = G::from_u64(281474976710656);
-        let __v_53: G = (__v_52 * __v_12);
-        let __v_54: G = G::from_u64(72057594037927936);
-        let __v_55: G = (__v_54 * __v_13);
-        let __v_56: G = (__v_53 + __v_55);
-        let __v_57: G = (__v_51 + __v_56);
-        let __v_58: G = (__v_49 + __v_57);
-        let __v_59: G = (__v_47 + __v_58);
-        let __v_60: G = (__v_45 + __v_59);
-        let __v_61: G = (__v_43 + __v_60);
-        let __v_62: G = (__v_6 + __v_61);
-        if (__v_62 != __v_3) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
-        }
-        let __v_63: G = G::from_u64(1);
-        let __v_64: G = G::from_u64(1);
-        let __v_65: G = (__v_64 - __v_23);
-        let __v_66: G = (__v_19 * __v_65);
-        let __v_67: G = (__v_63 - __v_66);
-        let __v_68: G = G::from_u64(1);
-        if (__v_67 != __v_68) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
-        }
-        let __v_69: G = G::from_u64(256);
-        let __v_70: G = (__v_69 * __v_25);
-        let __v_71: G = G::from_u64(65536);
-        let __v_72: G = (__v_71 * __v_26);
-        let __v_73: G = G::from_u64(16777216);
-        let __v_74: G = (__v_73 * __v_27);
-        let __v_75: G = G::from_u64(4294967296);
-        let __v_76: G = (__v_75 * __v_28);
-        let __v_77: G = G::from_u64(1099511627776);
-        let __v_78: G = (__v_77 * __v_29);
-        let __v_79: G = G::from_u64(281474976710656);
-        let __v_80: G = (__v_79 * __v_30);
-        let __v_81: G = G::from_u64(72057594037927936);
-        let __v_82: G = (__v_81 * __v_31);
-        let __v_83: G = (__v_80 + __v_82);
-        let __v_84: G = (__v_78 + __v_83);
-        let __v_85: G = (__v_76 + __v_84);
-        let __v_86: G = (__v_74 + __v_85);
-        let __v_87: G = (__v_72 + __v_86);
-        let __v_88: G = (__v_70 + __v_87);
-        let __v_89: G = (__v_24 + __v_88);
-        if (__v_89 != __v_4) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
-        }
-        let __v_90: G = G::from_u64(1);
-        let __v_91: G = G::from_u64(1);
-        let __v_92: G = (__v_91 - __v_41);
-        let __v_93: G = (__v_37 * __v_92);
-        let __v_94: G = (__v_90 - __v_93);
-        let __v_95: G = G::from_u64(1);
-        if (__v_94 != __v_95) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_98: G = __r_arr[0];
-        let __ret: [G; OUT_116] = [__v_98];
-        if let Some(result) = record.function_queries[116].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_116] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_3 - __v_4);
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[115].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = __r_arr[1];
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_3 - __v_8);
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_6, __v_7, __v_2, __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 { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_116] = [__v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[116].weight(); } record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_117: usize = 2;
-const IN_117: usize = 2;
+const INPUT_SIZE_117: usize = 6;
+const IN_117: usize = 6;
 const OUT_117: usize = 1;
 fn aiur_fn_117(
   inp: [G; IN_117],
@@ -11364,29 +11921,65 @@ fn aiur_fn_117(
   unconstrained: bool,
 ) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_117] = [__v_1];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_1, __v_2, __v_5]; 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 { let __r = record.function_queries[114].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+    let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_6]; 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 { let __r = record.function_queries[113].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_4, __v_2, __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 { let __r = record.function_queries[116].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_10: G = __loaded[0];
+    let __v_11: G = __loaded[1];
+    let __v_12: G = __loaded[2];
+    let __v_13: G = __loaded[3];
+    let __v_14: G = __loaded[4];
+    let __v_15: G = __loaded[5];
+    match __v_10.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_117] = [__v_6];
-        if let Some(result) = record.function_queries[117].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        match __v_11.as_canonical_u64() {
+          _ => {
+            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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+            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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __v_18: G = (__v_16 - __v_17);
+            let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+            let __v_20: G = G::from_u64(1);
+            if (__v_19 != __v_20) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = G::from_u64(0);
+            if (__v_21 != __v_22) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_15]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __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: None });
+            }
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_11]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+            let __v_26: G = (__v_25 - __v_14);
+            let __v_27: G = G::from_bool((__v_26 == G::ZERO));
+            let __ret: [G; OUT_117] = [__v_27];
+            if !unconstrained { record.virt += record.function_queries[117].weight(); } record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
       },
     }
   })
@@ -11402,25 +11995,26 @@ fn aiur_fn_118(
   unconstrained: bool,
 ) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __ret: [G; OUT_118] = [__v_1];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_117(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } } else { aiur_fn_117(__args, record, io_buffer, __cu)? } };
-        let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_118] = [__v_6];
-        if let Some(result) = record.function_queries[118].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_6]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+        let __ret: [G; OUT_118] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[118].weight(); } record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -11430,8 +12024,8 @@ fn aiur_fn_118(
   })
 }
 
-const INPUT_SIZE_119: usize = 3;
-const IN_119: usize = 3;
+const INPUT_SIZE_119: usize = 2;
+const IN_119: usize = 2;
 const OUT_119: usize = 1;
 fn aiur_fn_119(
   inp: [G; IN_119],
@@ -11440,67 +12034,37 @@ fn aiur_fn_119(
   unconstrained: bool,
 ) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_119] = [__v_2];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_119] = [__v_3];
-        if let Some(result) = record.function_queries[119].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_120: usize = 2;
-const IN_120: usize = 2;
-const OUT_120: usize = 1;
-fn aiur_fn_120(
-  inp: [G; IN_120],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_120] = [__v_0];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_5: G = G::from_u64(1);
+        let __ret: [G; OUT_119] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_120] = [__v_14];
-        if let Some(result) = record.function_queries[120].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __v_5: G = (__v_0 * __v_0);
+        let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_5, __v_4]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        match __v_3.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_119] = [__v_6];
+            if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_7: G = (__v_0 * __v_6);
+            let __ret: [G; OUT_119] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[119].weight(); } record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
@@ -11509,16 +12073,17 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 10;
-const IN_121: usize = 10;
-const OUT_121: usize = 2;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_120: usize = 8;
+const IN_120: usize = 8;
+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_121], ExecError> {
+) -> Result<[G; OUT_120], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -11527,424 +12092,425 @@ fn aiur_fn_121(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    match __v_9.as_canonical_u64() {
-      0u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_121] = [__v_0, __v_12];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
-        let __v_14: G = __r_arr[0];
-        let __v_15: G = __r_arr[1];
-        let __v_16: G = __r_arr[2];
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_107(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } } else { aiur_fn_107(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-        }
-        let __ret: [G; OUT_121] = [__v_15, __v_16];
-        if let Some(result) = record.function_queries[121].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_122: usize = 4;
-const IN_122: usize = 4;
-const OUT_122: usize = 2;
-fn aiur_fn_122(
-  inp: [G; IN_122],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_4: G = __loaded[0];
-    let __v_5: G = __loaded[1];
-    let __v_6: G = __loaded[2];
-    match __v_4.as_canonical_u64() {
-      1u64 => {
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_122] = [__v_9, __v_0];
-        if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
-        let __v_7: G = __loaded[0];
-        let __v_8: G = __loaded[1];
-        let __v_9: G = __loaded[2];
-        let __v_10: G = __loaded[3];
-        let __v_11: G = __loaded[4];
-        let __v_12: G = __loaded[5];
-        let __v_13: G = __loaded[6];
-        let __v_14: G = __loaded[7];
-        let __v_15: G = __loaded[8];
-        let __v_16: G = __loaded[9];
-        match __v_7.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-            let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-            let __v_18: G = __r_arr[0];
-            let __v_19: G = __r_arr[1];
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __v_21: G = __r_arr[1];
-            let __v_22: G = __r_arr[2];
-            let __v_23: G = __r_arr[3];
-            let __v_24: G = __r_arr[4];
-            let __v_25: G = __r_arr[5];
-            let __v_26: G = __r_arr[6];
-            let __v_27: G = __r_arr[7];
-            let __v_28: G = __r_arr[8];
-            let __v_29: G = __r_arr[9];
-            let __v_30: G = __r_arr[10];
-            let __v_31: G = __r_arr[11];
-            let __v_32: G = __r_arr[12];
-            let __v_33: G = __r_arr[13];
-            let __v_34: G = __r_arr[14];
-            let __v_35: G = __r_arr[15];
-            let __v_36: G = __r_arr[16];
-            let __v_37: G = __r_arr[17];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-            let __v_38: G = __r_arr[0];
-            let __v_39: G = __r_arr[1];
-            let __v_40: G = G::from_u64(0);
-            let __v_41: G = G::from_u64(256);
-            let __v_42: G = (__v_41 * __v_21);
-            let __v_43: G = G::from_u64(65536);
-            let __v_44: G = (__v_43 * __v_22);
-            let __v_45: G = G::from_u64(16777216);
-            let __v_46: G = (__v_45 * __v_23);
-            let __v_47: G = G::from_u64(4294967296);
-            let __v_48: G = (__v_47 * __v_24);
-            let __v_49: G = G::from_u64(1099511627776);
-            let __v_50: G = (__v_49 * __v_25);
-            let __v_51: G = G::from_u64(281474976710656);
-            let __v_52: G = (__v_51 * __v_26);
-            let __v_53: G = G::from_u64(72057594037927936);
-            let __v_54: G = (__v_53 * __v_27);
-            let __v_55: G = (__v_52 + __v_54);
-            let __v_56: G = (__v_50 + __v_55);
-            let __v_57: G = (__v_48 + __v_56);
-            let __v_58: G = (__v_46 + __v_57);
-            let __v_59: G = (__v_44 + __v_58);
-            let __v_60: G = (__v_42 + __v_59);
-            let __v_61: G = (__v_20 + __v_60);
-            let __v_62: G = G::from_u64(256);
-            let __v_63: G = (__v_62 * __v_29);
-            let __v_64: G = G::from_u64(65536);
-            let __v_65: G = (__v_64 * __v_30);
-            let __v_66: G = G::from_u64(16777216);
-            let __v_67: G = (__v_66 * __v_31);
-            let __v_68: G = G::from_u64(4294967296);
-            let __v_69: G = (__v_68 * __v_32);
-            let __v_70: G = G::from_u64(1099511627776);
-            let __v_71: G = (__v_70 * __v_33);
-            let __v_72: G = G::from_u64(281474976710656);
-            let __v_73: G = (__v_72 * __v_34);
-            let __v_74: G = G::from_u64(72057594037927936);
-            let __v_75: G = (__v_74 * __v_35);
-            let __v_76: G = (__v_73 + __v_75);
-            let __v_77: G = (__v_71 + __v_76);
-            let __v_78: G = (__v_69 + __v_77);
-            let __v_79: G = (__v_67 + __v_78);
-            let __v_80: G = (__v_65 + __v_79);
-            let __v_81: G = (__v_63 + __v_80);
-            let __v_82: G = (__v_28 + __v_81);
-            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_122] = [__v_83, __v_39];
-            if let Some(result) = record.function_queries[122].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-      },
+    let __v_8: G = G::from_u64(1);
+    let __v_9: G = (__v_1 + __v_8);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_9]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0, __v_13]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_10, __v_14]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = (__v_15 + __v_15);
+    let __v_17: G = (__v_4 + __v_6);
+    let __v_18: G = (__v_5 + __v_7);
+    let __v_19: G = G::from_u64(2);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_19 * __v_19);
+    let __v_22: G = G::from_u64(7);
+    let __v_23: G = (__v_20 * __v_20);
+    let __v_24: G = (__v_22 * __v_23);
+    let __v_25: G = (__v_21 - __v_24);
+    let __v_26: G = g_inverse_value(__v_25);
+    let __v_27: G = (__v_25 * __v_26);
+    let __v_28: G = G::from_u64(1);
+    let __v_29: G = (__v_27 - __v_28);
+    let __v_30: G = (__v_25 * __v_29);
+    let __v_31: G = G::from_u64(0);
+    if (__v_30 != __v_31) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+    }
+    let __v_32: G = (__v_26 * __v_29);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
+    }
+    let __v_34: G = (__v_19 * __v_26);
+    let __v_35: G = G::from_u64(0);
+    let __v_36: G = (__v_35 - __v_20);
+    let __v_37: G = (__v_36 * __v_26);
+    let __v_38: G = (__v_17 * __v_34);
+    let __v_39: G = G::from_u64(7);
+    let __v_40: G = (__v_18 * __v_37);
+    let __v_41: G = (__v_39 * __v_40);
+    let __v_42: G = (__v_38 + __v_41);
+    let __v_43: G = (__v_17 * __v_37);
+    let __v_44: G = (__v_18 * __v_34);
+    let __v_45: G = (__v_43 + __v_44);
+    let __v_46: G = (__v_4 - __v_6);
+    let __v_47: G = (__v_5 - __v_7);
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = (__v_16 * __v_16);
+    let __v_50: G = G::from_u64(7);
+    let __v_51: G = (__v_48 * __v_48);
+    let __v_52: G = (__v_50 * __v_51);
+    let __v_53: G = (__v_49 - __v_52);
+    let __v_54: G = g_inverse_value(__v_53);
+    let __v_55: G = (__v_53 * __v_54);
+    let __v_56: G = G::from_u64(1);
+    let __v_57: G = (__v_55 - __v_56);
+    let __v_58: G = (__v_53 * __v_57);
+    let __v_59: G = G::from_u64(0);
+    if (__v_58 != __v_59) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_59.as_canonical_u64(), msg: None });
+    }
+    let __v_60: G = (__v_54 * __v_57);
+    let __v_61: G = G::from_u64(0);
+    if (__v_60 != __v_61) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: None });
     }
+    let __v_62: G = (__v_16 * __v_54);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = (__v_63 - __v_48);
+    let __v_65: G = (__v_64 * __v_54);
+    let __v_66: G = (__v_46 * __v_62);
+    let __v_67: G = G::from_u64(7);
+    let __v_68: G = (__v_47 * __v_65);
+    let __v_69: G = (__v_67 * __v_68);
+    let __v_70: G = (__v_66 + __v_69);
+    let __v_71: G = (__v_46 * __v_65);
+    let __v_72: G = (__v_47 * __v_62);
+    let __v_73: G = (__v_71 + __v_72);
+    let __v_74: G = (__v_2 * __v_70);
+    let __v_75: G = G::from_u64(7);
+    let __v_76: G = (__v_3 * __v_73);
+    let __v_77: G = (__v_75 * __v_76);
+    let __v_78: G = (__v_74 + __v_77);
+    let __v_79: G = (__v_2 * __v_73);
+    let __v_80: G = (__v_3 * __v_70);
+    let __v_81: G = (__v_79 + __v_80);
+    let __v_82: G = (__v_42 + __v_78);
+    let __v_83: G = (__v_45 + __v_81);
+    let __ret: [G; OUT_120] = [__v_82, __v_83];
+    if !unconstrained { record.virt += record.function_queries[120].weight(); } record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_123: usize = 5;
-const IN_123: usize = 5;
-const OUT_123: usize = 1;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_121: usize = 2;
+const IN_121: usize = 2;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_121], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_123] = [__v_5];
-        if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = (__v_1 - __v_4);
-        let __v_7: G = (__v_5 + __v_6);
-        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
-        match __v_8.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_123] = [__v_9];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_2 - __v_9);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 + __v_11);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_123] = [__v_13];
-            if let Some(result) = record.function_queries[123].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-    }
+    let __v_2: G = G::from_u64(7);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_1]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0, __v_6]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_7: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_7]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = (__v_2 * __v_8);
+    let __ret: [G; OUT_121] = [__v_9];
+    if !unconstrained { record.virt += record.function_queries[121].weight(); } record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_124: usize = 4;
-const IN_124: usize = 4;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_122: usize = 8;
+const IN_122: usize = 8;
+const OUT_122: usize = 4;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_124], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_124] = [__v_6];
-        if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    let __v_15: G = __loaded[7];
+    let __v_16: G = __loaded[8];
+    let __v_17: G = __loaded[9];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_122] = [__v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_123(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } } else { aiur_fn_123(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_3 - __v_6);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_124] = [__v_8];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_18: G = __loaded[0];
+        let __v_19: G = __loaded[1];
+        let __v_20: G = __loaded[2];
+        let __v_21: G = __loaded[3];
+        match __v_18.as_canonical_u64() {
+          0u64 => {
+            let __v_22: G = G::from_u64(256);
+            let __v_23: G = (__v_22 * __v_10);
+            let __v_24: G = G::from_u64(65536);
+            let __v_25: G = (__v_24 * __v_11);
+            let __v_26: G = G::from_u64(16777216);
+            let __v_27: G = (__v_26 * __v_12);
+            let __v_28: G = G::from_u64(4294967296);
+            let __v_29: G = (__v_28 * __v_13);
+            let __v_30: G = G::from_u64(1099511627776);
+            let __v_31: G = (__v_30 * __v_14);
+            let __v_32: G = G::from_u64(281474976710656);
+            let __v_33: G = (__v_32 * __v_15);
+            let __v_34: G = G::from_u64(72057594037927936);
+            let __v_35: G = (__v_34 * __v_16);
+            let __v_36: G = (__v_33 + __v_35);
+            let __v_37: G = (__v_31 + __v_36);
+            let __v_38: G = (__v_29 + __v_37);
+            let __v_39: G = (__v_27 + __v_38);
+            let __v_40: G = (__v_25 + __v_39);
+            let __v_41: G = (__v_23 + __v_40);
+            let __v_42: G = (__v_9 + __v_41);
+            let __v_43: G = G::from_u64(0);
+            let __v_44: G = (__v_19 - __v_42);
+            let __v_45: G = (__v_20 - __v_43);
+            let __v_46: G = (__v_6 * __v_44);
+            let __v_47: G = G::from_u64(7);
+            let __v_48: G = (__v_7 * __v_45);
+            let __v_49: G = (__v_47 * __v_48);
+            let __v_50: G = (__v_46 + __v_49);
+            let __v_51: G = (__v_6 * __v_45);
+            let __v_52: G = (__v_7 * __v_44);
+            let __v_53: G = (__v_51 + __v_52);
+            let __v_54: G = (__v_4 + __v_50);
+            let __v_55: G = (__v_5 + __v_53);
+            let __v_56: G = (__v_6 * __v_2);
+            let __v_57: G = G::from_u64(7);
+            let __v_58: G = (__v_7 * __v_3);
+            let __v_59: G = (__v_57 * __v_58);
+            let __v_60: G = (__v_56 + __v_59);
+            let __v_61: G = (__v_6 * __v_3);
+            let __v_62: G = (__v_7 * __v_2);
+            let __v_63: G = (__v_61 + __v_62);
+            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; 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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+            let __v_65: G = __r_arr[1];
+            let __v_66: G = __r_arr[2];
+            let __v_67: G = __r_arr[3];
+            let __ret: [G; OUT_122] = [__v_64, __v_65, __v_66, __v_67];
+            if !unconstrained { record.virt += record.function_queries[122].weight(); } record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __v_6: G = G::from_u64(0);
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(0);
-            let __v_9: G = G::from_u64(0);
-            let __v_10: G = G::from_u64(0);
-            let __v_11: G = G::from_u64(1);
-            let __v_12: G = (__v_3 - __v_11);
-            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-            let __v_13: G = __r_arr[0];
-            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_124] = [__v_14];
-            if let Some(result) = record.function_queries[124].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
+            return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_125: usize = 8;
-const IN_125: usize = 8;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+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_125], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_8: G = __loaded[0];
-    let __v_9: G = __loaded[1];
-    let __v_10: G = __loaded[2];
-    let __v_11: G = __loaded[3];
-    let __v_12: G = __loaded[4];
-    let __v_13: G = __loaded[5];
-    let __v_14: G = __loaded[6];
-    match __v_8.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_15: G = G::from_u64(1);
-        let __v_16: G = G::from_u64(1);
-        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_125] = [__v_17];
-        if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_123] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        match __v_9.as_canonical_u64() {
-          _ => {
-            let __v_15: G = (__v_9 - __v_1);
-            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-            match __v_16.as_canonical_u64() {
-              1u64 => {
-                let __v_17: G = G::from_u64(0);
-                let __v_18: G = G::from_u64(0);
-                let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_115(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } } else { aiur_fn_115(__args, record, io_buffer, __cu)? } };
-                let __v_19: G = __r_arr[0];
-                let __v_20: G = __r_arr[1];
-                let __v_21: G = __r_arr[2];
-                let __v_22: G = __r_arr[3];
-                let __v_23: G = (__v_4 * __v_19);
-                let __v_24: G = G::from_u64(7);
-                let __v_25: G = (__v_5 * __v_20);
-                let __v_26: G = (__v_24 * __v_25);
-                let __v_27: G = (__v_23 + __v_26);
-                let __v_28: G = (__v_4 * __v_20);
-                let __v_29: G = (__v_5 * __v_19);
-                let __v_30: G = (__v_28 + __v_29);
-                let __v_31: G = (__v_12 + __v_27);
-                let __v_32: G = (__v_13 + __v_30);
-                let __v_33: G = G::from_u64(0);
-                let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_34];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_17: G = G::from_u64(0);
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-                let __v_18: G = __r_arr[0];
-                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_125] = [__v_19];
-                if let Some(result) = record.function_queries[125].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
+        let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+        let __v_6: G = G::from_u8(__gb[0]);
+        let __v_7: G = G::from_u8(__gb[1]);
+        let __v_8: G = G::from_u8(__gb[2]);
+        let __v_9: G = G::from_u8(__gb[3]);
+        let __v_10: G = G::from_u8(__gb[4]);
+        let __v_11: G = G::from_u8(__gb[5]);
+        let __v_12: G = G::from_u8(__gb[6]);
+        let __v_13: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_14: G = G::from_u64(1020);
+        let __v_15: G = (__v_13 - __v_14);
+        let __v_16: G = (__v_12 + __v_15);
+        let __v_17: G = (__v_11 + __v_16);
+        let __v_18: G = (__v_10 + __v_17);
+        let __v_19: G = G::from_bool((__v_18 == G::ZERO));
+        let __v_20: G = (__v_8 + __v_9);
+        let __v_21: G = (__v_7 + __v_20);
+        let __v_22: G = (__v_6 + __v_21);
+        let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+        let __gb: [u8; 8] = __v_4.as_canonical_u64().to_le_bytes();
+        let __v_24: G = G::from_u8(__gb[0]);
+        let __v_25: G = G::from_u8(__gb[1]);
+        let __v_26: G = G::from_u8(__gb[2]);
+        let __v_27: G = G::from_u8(__gb[3]);
+        let __v_28: G = G::from_u8(__gb[4]);
+        let __v_29: G = G::from_u8(__gb[5]);
+        let __v_30: G = G::from_u8(__gb[6]);
+        let __v_31: G = G::from_u8(__gb[7]);
+        if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+        let __v_32: G = G::from_u64(1020);
+        let __v_33: G = (__v_31 - __v_32);
+        let __v_34: G = (__v_30 + __v_33);
+        let __v_35: G = (__v_29 + __v_34);
+        let __v_36: G = (__v_28 + __v_35);
+        let __v_37: G = G::from_bool((__v_36 == G::ZERO));
+        let __v_38: G = (__v_26 + __v_27);
+        let __v_39: G = (__v_25 + __v_38);
+        let __v_40: G = (__v_24 + __v_39);
+        let __v_41: G = G::from_bool((__v_40 == G::ZERO));
+        let __v_42: G = G::from_u64(256);
+        let __v_43: G = (__v_42 * __v_7);
+        let __v_44: G = G::from_u64(65536);
+        let __v_45: G = (__v_44 * __v_8);
+        let __v_46: G = G::from_u64(16777216);
+        let __v_47: G = (__v_46 * __v_9);
+        let __v_48: G = G::from_u64(4294967296);
+        let __v_49: G = (__v_48 * __v_10);
+        let __v_50: G = G::from_u64(1099511627776);
+        let __v_51: G = (__v_50 * __v_11);
+        let __v_52: G = G::from_u64(281474976710656);
+        let __v_53: G = (__v_52 * __v_12);
+        let __v_54: G = G::from_u64(72057594037927936);
+        let __v_55: G = (__v_54 * __v_13);
+        let __v_56: G = (__v_53 + __v_55);
+        let __v_57: G = (__v_51 + __v_56);
+        let __v_58: G = (__v_49 + __v_57);
+        let __v_59: G = (__v_47 + __v_58);
+        let __v_60: G = (__v_45 + __v_59);
+        let __v_61: G = (__v_43 + __v_60);
+        let __v_62: G = (__v_6 + __v_61);
+        if (__v_62 != __v_3) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+        }
+        let __v_63: G = G::from_u64(1);
+        let __v_64: G = G::from_u64(1);
+        let __v_65: G = (__v_64 - __v_23);
+        let __v_66: G = (__v_19 * __v_65);
+        let __v_67: G = (__v_63 - __v_66);
+        let __v_68: G = G::from_u64(1);
+        if (__v_67 != __v_68) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_68.as_canonical_u64(), msg: None });
+        }
+        let __v_69: G = G::from_u64(256);
+        let __v_70: G = (__v_69 * __v_25);
+        let __v_71: G = G::from_u64(65536);
+        let __v_72: G = (__v_71 * __v_26);
+        let __v_73: G = G::from_u64(16777216);
+        let __v_74: G = (__v_73 * __v_27);
+        let __v_75: G = G::from_u64(4294967296);
+        let __v_76: G = (__v_75 * __v_28);
+        let __v_77: G = G::from_u64(1099511627776);
+        let __v_78: G = (__v_77 * __v_29);
+        let __v_79: G = G::from_u64(281474976710656);
+        let __v_80: G = (__v_79 * __v_30);
+        let __v_81: G = G::from_u64(72057594037927936);
+        let __v_82: G = (__v_81 * __v_31);
+        let __v_83: G = (__v_80 + __v_82);
+        let __v_84: G = (__v_78 + __v_83);
+        let __v_85: G = (__v_76 + __v_84);
+        let __v_86: G = (__v_74 + __v_85);
+        let __v_87: G = (__v_72 + __v_86);
+        let __v_88: G = (__v_70 + __v_87);
+        let __v_89: G = (__v_24 + __v_88);
+        if (__v_89 != __v_4) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+        }
+        let __v_90: G = G::from_u64(1);
+        let __v_91: G = G::from_u64(1);
+        let __v_92: G = (__v_91 - __v_41);
+        let __v_93: G = (__v_37 * __v_92);
+        let __v_94: G = (__v_90 - __v_93);
+        let __v_95: G = G::from_u64(1);
+        if (__v_94 != __v_95) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_95.as_canonical_u64(), msg: None });
         }
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_5, __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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+        let __ret: [G; OUT_123] = [__v_98];
+        if !unconstrained { record.virt += record.function_queries[123].weight(); } record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_126: usize = 2;
-const IN_126: usize = 2;
-const OUT_126: usize = 1;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_124: usize = 2;
+const IN_124: usize = 2;
+const OUT_124: usize = 1;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_9: G = G::from_u64(1);
-        let __ret: [G; OUT_126] = [__v_9];
-        if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_124] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        match __v_3.as_canonical_u64() {
-          _ => {
-            let __v_9: G = (__v_3 - __v_1);
-            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
-            match __v_10.as_canonical_u64() {
-              1u64 => {
-                let __v_11: G = G::from_u64(0);
-                let __v_12: G = G::from_u64(0);
-                let __v_13: G = (__v_6 - __v_11);
-                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-                let __v_15: G = (__v_7 - __v_12);
-                let __v_16: G = G::from_bool((__v_15 == G::ZERO));
-                let __v_17: G = (__v_14 * __v_16);
-                let __v_18: G = G::from_u64(1);
-                if (__v_17 != __v_18) {
-                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-                }
-                let __v_19: G = G::from_u64(1);
-                let __ret: [G; OUT_126] = [__v_19];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
-                let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_126] = [__v_11];
-                if let Some(result) = record.function_queries[126].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_4, __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 { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_5]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_124] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[124].weight(); } record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
       _ => {
         return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
@@ -11953,174 +12519,137 @@ fn aiur_fn_126(
   })
 }
 
-const INPUT_SIZE_127: usize = 2;
-const IN_127: usize = 2;
-const OUT_127: usize = 1;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_125: usize = 2;
+const IN_125: usize = 2;
+const OUT_125: usize = 1;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_125] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_127] = [__v_2];
-        if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      0u64 => {
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; 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 { let __r = record.function_queries[124].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __ret: [G; OUT_125] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[125].weight(); } record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_128: usize = 10;
-const IN_128: usize = 10;
-const OUT_128: usize = 1;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_126: usize = 3;
+const IN_126: usize = 3;
+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_128], ExecError> {
+) -> Result<[G; OUT_126], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = (__v_3 - __v_1);
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = G::from_u64(7);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(1);
-    let __v_15: G = G::from_u64(1);
-    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } };
-    let __v_18: G = __r_arr[0];
-    let __v_19: G = (__v_12 * __v_18);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = (__v_4 - __v_19);
-    let __v_22: G = (__v_5 - __v_20);
-    let __v_23: G = (__v_21 * __v_21);
-    let __v_24: G = G::from_u64(7);
-    let __v_25: G = (__v_22 * __v_22);
-    let __v_26: G = (__v_24 * __v_25);
-    let __v_27: G = (__v_23 - __v_26);
-    let __v_28: G = g_inverse_value(__v_27);
-    let __v_29: G = (__v_27 * __v_28);
-    let __v_30: G = G::from_u64(1);
-    let __v_31: G = (__v_29 - __v_30);
-    let __v_32: G = (__v_27 * __v_31);
-    let __v_33: G = G::from_u64(0);
-    if (__v_32 != __v_33) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
-    }
-    let __v_34: G = (__v_28 * __v_31);
-    let __v_35: G = G::from_u64(0);
-    if (__v_34 != __v_35) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
-    }
-    let __v_36: G = (__v_21 * __v_28);
-    let __v_37: G = G::from_u64(0);
-    let __v_38: G = (__v_37 - __v_22);
-    let __v_39: G = (__v_38 * __v_28);
-    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-    let __v_40: G = __r_arr[0];
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_41: G = __r_arr[0];
-    let __v_42: G = (__v_40 - __v_41);
-    let __v_43: G = G::from_bool((__v_42 == G::ZERO));
-    let __v_44: G = G::from_u64(1);
-    if (__v_43 != __v_44) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_126] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_126] = [__v_3];
+        if !unconstrained { record.virt += record.function_queries[126].weight(); } record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } };
-    let __v_45: G = __r_arr[0];
-    let __ret: [G; OUT_128] = [__v_45];
-    if let Some(result) = record.function_queries[128].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 11;
-const IN_129: usize = 11;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_127: usize = 2;
+const IN_127: usize = 2;
+const OUT_127: usize = 1;
+fn aiur_fn_127(
+  inp: [G; IN_127],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_129], ExecError> {
+) -> Result<[G; OUT_127], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = G::from_u64(0);
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __v_13: G = G::from_u64(1);
-    let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-    let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = (__v_5 * __v_15);
-    let __v_18: G = G::from_u64(7);
-    let __v_19: G = (__v_6 * __v_16);
-    let __v_20: G = (__v_18 * __v_19);
-    let __v_21: G = (__v_17 + __v_20);
-    let __v_22: G = (__v_5 * __v_16);
-    let __v_23: G = (__v_6 * __v_15);
-    let __v_24: G = (__v_22 + __v_23);
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-    let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __ret: [G; OUT_129] = [__v_26];
-    if let Some(result) = record.function_queries[129].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_127] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __v_12: G = G::from_u64(0);
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_127] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[127].weight(); } record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_130: usize = 13;
-const IN_130: usize = 13;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_128: usize = 10;
+const IN_128: usize = 10;
+const OUT_128: usize = 2;
+fn aiur_fn_128(
+  inp: [G; IN_128],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_130], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12131,772 +12660,607 @@ fn aiur_fn_130(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    match __v_5.as_canonical_u64() {
+    match __v_9.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_130] = [__v_0];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_128] = [__v_0, __v_12];
+        if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__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[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[170].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_10, __v_13, __v_9]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+        let __v_15: G = __r_arr[1];
+        let __v_16: G = __r_arr[2];
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[110].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(1);
-        let __v_19: G = (__v_4 + __v_18);
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = (__v_5 - __v_20);
-        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __ret: [G; OUT_130] = [__v_22];
-        if let Some(result) = record.function_queries[130].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_18: G = G::from_u64(0);
+        if (__v_17 != __v_18) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+        }
+        let __ret: [G; OUT_128] = [__v_15, __v_16];
+        if !unconstrained { record.virt += record.function_queries[128].weight(); } record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_131: usize = 13;
-const IN_131: usize = 13;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+const INPUT_SIZE_129: usize = 4;
+const IN_129: usize = 4;
+const OUT_129: usize = 2;
+fn aiur_fn_129(
+  inp: [G; IN_129],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    match __v_5.as_canonical_u64() {
-      0u64 => {
-        let __ret: [G; OUT_131] = [__v_0];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_5: G = __loaded[1];
+    let __v_6: G = __loaded[2];
+    match __v_4.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_129] = [__v_9, __v_0];
+        if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = (__v_13 + __v_3);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_128(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } } else { aiur_fn_128(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = G::from_u64(1);
-        let __v_21: G = (__v_4 + __v_20);
-        let __v_22: G = G::from_u64(1);
-        let __v_23: G = (__v_5 - __v_22);
-        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_131] = [__v_24];
-        if let Some(result) = record.function_queries[131].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_132: usize = 15;
-const IN_132: usize = 15;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_132], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_132] = [__v_0];
-        if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_15: G = __r_arr[0];
-        let __v_16: G = __r_arr[1];
-        match __v_15.as_canonical_u64() {
+        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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+        let __v_7: G = __loaded[0];
+        let __v_8: G = __loaded[1];
+        let __v_9: G = __loaded[2];
+        let __v_10: G = __loaded[3];
+        let __v_11: G = __loaded[4];
+        let __v_12: G = __loaded[5];
+        let __v_13: G = __loaded[6];
+        let __v_14: G = __loaded[7];
+        let __v_15: G = __loaded[8];
+        let __v_16: G = __loaded[9];
+        match __v_7.as_canonical_u64() {
           0u64 => {
-            let __v_17: G = G::from_u64(1);
-            let __v_18: G = (__v_4 + __v_17);
-            let __v_19: G = G::from_u64(1);
-            let __v_20: G = (__v_5 - __v_19);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_21];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_5]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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 __v_18: G = (__v_17 + __v_3);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+            let __v_19: G = __r_arr[1];
+            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_18, __v_19]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = G::from_u64(1);
-            let __v_23: G = (__v_4 + __v_22);
-            let __v_24: G = G::from_u64(1);
-            let __v_25: G = (__v_5 - __v_24);
-            let __v_26: G = G::from_u64(1);
-            let __v_27: G = (__v_6 + __v_26);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_132] = [__v_28];
-            if let Some(result) = record.function_queries[132].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_21: G = __r_arr[1];
+            let __v_22: G = __r_arr[2];
+            let __v_23: G = __r_arr[3];
+            let __v_24: G = __r_arr[4];
+            let __v_25: G = __r_arr[5];
+            let __v_26: G = __r_arr[6];
+            let __v_27: G = __r_arr[7];
+            let __v_28: G = __r_arr[8];
+            let __v_29: G = __r_arr[9];
+            let __v_30: G = __r_arr[10];
+            let __v_31: G = __r_arr[11];
+            let __v_32: G = __r_arr[12];
+            let __v_33: G = __r_arr[13];
+            let __v_34: G = __r_arr[14];
+            let __v_35: G = __r_arr[15];
+            let __v_36: G = __r_arr[16];
+            let __v_37: G = __r_arr[17];
+            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_36, __v_6, __v_16, __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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+            let __v_39: G = __r_arr[1];
+            let __v_40: G = G::from_u64(0);
+            let __v_41: G = G::from_u64(256);
+            let __v_42: G = (__v_41 * __v_21);
+            let __v_43: G = G::from_u64(65536);
+            let __v_44: G = (__v_43 * __v_22);
+            let __v_45: G = G::from_u64(16777216);
+            let __v_46: G = (__v_45 * __v_23);
+            let __v_47: G = G::from_u64(4294967296);
+            let __v_48: G = (__v_47 * __v_24);
+            let __v_49: G = G::from_u64(1099511627776);
+            let __v_50: G = (__v_49 * __v_25);
+            let __v_51: G = G::from_u64(281474976710656);
+            let __v_52: G = (__v_51 * __v_26);
+            let __v_53: G = G::from_u64(72057594037927936);
+            let __v_54: G = (__v_53 * __v_27);
+            let __v_55: G = (__v_52 + __v_54);
+            let __v_56: G = (__v_50 + __v_55);
+            let __v_57: G = (__v_48 + __v_56);
+            let __v_58: G = (__v_46 + __v_57);
+            let __v_59: G = (__v_44 + __v_58);
+            let __v_60: G = (__v_42 + __v_59);
+            let __v_61: G = (__v_20 + __v_60);
+            let __v_62: G = G::from_u64(256);
+            let __v_63: G = (__v_62 * __v_29);
+            let __v_64: G = G::from_u64(65536);
+            let __v_65: G = (__v_64 * __v_30);
+            let __v_66: G = G::from_u64(16777216);
+            let __v_67: G = (__v_66 * __v_31);
+            let __v_68: G = G::from_u64(4294967296);
+            let __v_69: G = (__v_68 * __v_32);
+            let __v_70: G = G::from_u64(1099511627776);
+            let __v_71: G = (__v_70 * __v_33);
+            let __v_72: G = G::from_u64(281474976710656);
+            let __v_73: G = (__v_72 * __v_34);
+            let __v_74: G = G::from_u64(72057594037927936);
+            let __v_75: G = (__v_74 * __v_35);
+            let __v_76: G = (__v_73 + __v_75);
+            let __v_77: G = (__v_71 + __v_76);
+            let __v_78: G = (__v_69 + __v_77);
+            let __v_79: G = (__v_67 + __v_78);
+            let __v_80: G = (__v_65 + __v_79);
+            let __v_81: G = (__v_63 + __v_80);
+            let __v_82: G = (__v_28 + __v_81);
+            let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_129] = [__v_83, __v_39];
+            if !unconstrained { record.virt += record.function_queries[129].weight(); } record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_133: usize = 15;
-const IN_133: usize = 15;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_130: usize = 5;
+const IN_130: usize = 5;
+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_133], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    match __v_3.as_canonical_u64() {
+    match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_133] = [__v_0];
-        if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_130] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      1u64 => {
-        let __v_15: G = G::from_u64(3);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        match __v_16.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_3]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = (__v_1 - __v_4);
+        let __v_7: G = (__v_5 + __v_6);
+        let __v_8: G = G::from_bool((__v_7 == G::ZERO));
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_u64(1);
+            let __ret: [G; OUT_130] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
           _ => {
-            let __v_18: G = G::from_u64(0);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-            let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-            let __v_22: G = __r_arr[0];
-            let __v_23: G = (__v_21 - __v_22);
-            let __v_24: G = G::from_bool((__v_23 == G::ZERO));
-            let __v_25: G = G::from_u64(1);
-            if (__v_24 != __v_25) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
-            }
-            let __v_26: G = (__v_9 - __v_20);
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
-            let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __v_29: G = G::from_u64(1);
-            if (__v_28 != __v_29) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
-            }
-            let __v_30: G = G::from_u64(0);
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __ret: [G; OUT_133] = [__v_32];
-            if let Some(result) = record.function_queries[133].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_2 - __v_9);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 + __v_11);
+            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_10, __v_12, __v_4]; 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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __ret: [G; OUT_130] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[130].weight(); } record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_134: usize = 4;
-const IN_134: usize = 4;
-const OUT_134: usize = 1;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+const INPUT_SIZE_131: usize = 4;
+const IN_131: usize = 4;
+const OUT_131: usize = 1;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    match __v_2.as_canonical_u64() {
+    match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_6];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_131] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_2, __v_4, __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 { let __r = record.function_queries[130].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
-        let __v_6: G = (__v_5 + __v_1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = (__v_2 - __v_7);
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_3 + __v_9);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_134] = [__v_12];
-        if let Some(result) = record.function_queries[134].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_135: usize = 1;
-const IN_135: usize = 1;
-const OUT_135: usize = 1;
-fn aiur_fn_135(
-  inp: [G; IN_135],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_135] = [__v_4];
-        if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_135(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } } else { aiur_fn_135(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_135] = [__v_4];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_3 - __v_6);
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_131] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_135] = [__v_2];
-            if let Some(result) = record.function_queries[135].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __v_6: G = G::from_u64(0);
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(1);
+            let __v_12: G = (__v_3 - __v_11);
+            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_12]; 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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+            let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_131] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[131].weight(); } record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_136: usize = 5;
-const IN_136: usize = 5;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
-  record: &mut QueryRecord,
+const INPUT_SIZE_132: usize = 8;
+const IN_132: usize = 8;
+const OUT_132: usize = 1;
+fn aiur_fn_132(
+  inp: [G; IN_132],
+  record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_136], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    match __v_3.as_canonical_u64() {
-      0u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_136] = [__v_7];
-        if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_8: G = __loaded[0];
+    let __v_9: G = __loaded[1];
+    let __v_10: G = __loaded[2];
+    let __v_11: G = __loaded[3];
+    let __v_12: G = __loaded[4];
+    let __v_13: G = __loaded[5];
+    let __v_14: G = __loaded[6];
+    match __v_8.as_canonical_u64() {
+      1u64 => {
+        let __v_15: G = G::from_u64(1);
+        let __v_16: G = G::from_u64(1);
+        let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_132] = [__v_17];
+        if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = __r_arr[1];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = (__v_3 - __v_7);
-            let __v_9: G = G::from_u64(1);
-            let __v_10: G = (__v_4 + __v_9);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_136] = [__v_11];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __v_9: G = (__v_8 + __v_1);
-            let __v_10: G = G::from_u64(1);
-            let __v_11: G = (__v_3 - __v_10);
-            let __v_12: G = G::from_u64(1);
-            let __v_13: G = (__v_4 + __v_12);
-            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_136(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } } else { aiur_fn_136(__args, record, io_buffer, __cu)? } };
-            let __v_14: G = __r_arr[0];
-            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_136] = [__v_15];
-            if let Some(result) = record.function_queries[136].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
+      0u64 => {
+        match __v_9.as_canonical_u64() {
+          _ => {
+            let __v_15: G = (__v_9 - __v_1);
+            let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+            match __v_16.as_canonical_u64() {
+              1u64 => {
+                let __v_17: G = G::from_u64(0);
+                let __v_18: G = G::from_u64(0);
+                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; 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 { let __r = record.function_queries[122].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+                let __v_20: G = __r_arr[1];
+                let __v_21: G = __r_arr[2];
+                let __v_22: G = __r_arr[3];
+                let __v_23: G = (__v_4 * __v_19);
+                let __v_24: G = G::from_u64(7);
+                let __v_25: G = (__v_5 * __v_20);
+                let __v_26: G = (__v_24 * __v_25);
+                let __v_27: G = (__v_23 + __v_26);
+                let __v_28: G = (__v_4 * __v_20);
+                let __v_29: G = (__v_5 * __v_19);
+                let __v_30: G = (__v_28 + __v_29);
+                let __v_31: G = (__v_12 + __v_27);
+                let __v_32: G = (__v_13 + __v_30);
+                let __v_33: G = G::from_u64(0);
+                let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_132] = [__v_34];
+                if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_17: G = G::from_u64(0);
+                let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+                let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_132] = [__v_19];
+                if !unconstrained { record.virt += record.function_queries[132].weight(); } record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
           },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_133: usize = 2;
+const IN_133: usize = 2;
+const OUT_133: usize = 1;
+fn aiur_fn_133(
+  inp: [G; IN_133],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_133], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(1);
+        let __ret: [G; OUT_133] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
           _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+            let __v_9: G = (__v_3 - __v_1);
+            let __v_10: G = G::from_bool((__v_9 == G::ZERO));
+            match __v_10.as_canonical_u64() {
+              1u64 => {
+                let __v_11: G = G::from_u64(0);
+                let __v_12: G = G::from_u64(0);
+                let __v_13: G = (__v_6 - __v_11);
+                let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+                let __v_15: G = (__v_7 - __v_12);
+                let __v_16: G = G::from_bool((__v_15 == G::ZERO));
+                let __v_17: G = (__v_14 * __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_17 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                let __v_19: G = G::from_u64(1);
+                let __ret: [G; OUT_133] = [__v_19];
+                if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_8, __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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_11: G = __r_arr[0];
+                let __ret: [G; OUT_133] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[133].weight(); } record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
           },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_137: usize = 5;
-const IN_137: usize = 5;
-const OUT_137: usize = 4;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+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_137], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_2: G = G::from_u64(0);
+        let __ret: [G; OUT_134] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __ret: [G; OUT_137] = [__v_3, __v_4, __v_1, __v_2];
-        if let Some(result) = record.function_queries[137].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      1u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __ret: [G; OUT_134] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[134].weight(); } record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_138: usize = 4;
-const IN_138: usize = 4;
-const OUT_138: usize = 1;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_135: usize = 10;
+const IN_135: usize = 10;
+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_138], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
-    let __v_4: G = G::from_u8(__gb[0]);
-    let __v_5: G = G::from_u8(__gb[1]);
-    let __v_6: G = G::from_u8(__gb[2]);
-    let __v_7: G = G::from_u8(__gb[3]);
-    let __v_8: G = G::from_u8(__gb[4]);
-    let __v_9: G = G::from_u8(__gb[5]);
-    let __v_10: G = G::from_u8(__gb[6]);
-    let __v_11: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_12: G = G::from_u64(1020);
-    let __v_13: G = (__v_11 - __v_12);
-    let __v_14: G = (__v_10 + __v_13);
-    let __v_15: G = (__v_9 + __v_14);
-    let __v_16: G = (__v_8 + __v_15);
-    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
-    let __v_18: G = (__v_6 + __v_7);
-    let __v_19: G = (__v_5 + __v_18);
-    let __v_20: G = (__v_4 + __v_19);
-    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
-    let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes();
-    let __v_22: G = G::from_u8(__gb[0]);
-    let __v_23: G = G::from_u8(__gb[1]);
-    let __v_24: G = G::from_u8(__gb[2]);
-    let __v_25: G = G::from_u8(__gb[3]);
-    let __v_26: G = G::from_u8(__gb[4]);
-    let __v_27: G = G::from_u8(__gb[5]);
-    let __v_28: G = G::from_u8(__gb[6]);
-    let __v_29: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_22; let __vj = __v_23; 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_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-    let __v_30: G = G::from_u64(1020);
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = (__v_3 - __v_1);
+    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_10]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(7);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_1]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(1);
+    let __v_15: G = G::from_u64(1);
+    let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_11, __v_16]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_17: G = __r_arr[0];
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_13, __v_17]; 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 { let __r = record.function_queries[119].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+    let __v_19: G = (__v_12 * __v_18);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = (__v_4 - __v_19);
+    let __v_22: G = (__v_5 - __v_20);
+    let __v_23: G = (__v_21 * __v_21);
+    let __v_24: G = G::from_u64(7);
+    let __v_25: G = (__v_22 * __v_22);
+    let __v_26: G = (__v_24 * __v_25);
+    let __v_27: G = (__v_23 - __v_26);
+    let __v_28: G = g_inverse_value(__v_27);
+    let __v_29: G = (__v_27 * __v_28);
+    let __v_30: G = G::from_u64(1);
     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 __v_34: G = (__v_26 + __v_33);
-    let __v_35: G = G::from_bool((__v_34 == G::ZERO));
-    let __v_36: G = (__v_24 + __v_25);
-    let __v_37: G = (__v_23 + __v_36);
-    let __v_38: G = (__v_22 + __v_37);
-    let __v_39: G = G::from_bool((__v_38 == G::ZERO));
-    let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
-    let __v_40: G = G::from_u8(__gb[0]);
-    let __v_41: G = G::from_u8(__gb[1]);
-    let __v_42: G = G::from_u8(__gb[2]);
-    let __v_43: G = G::from_u8(__gb[3]);
-    let __v_44: G = G::from_u8(__gb[4]);
-    let __v_45: G = G::from_u8(__gb[5]);
-    let __v_46: G = G::from_u8(__gb[6]);
-    let __v_47: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_44; let __vj = __v_45; 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_46; let __vj = __v_47; 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_48: G = G::from_u64(1020);
-    let __v_49: G = (__v_47 - __v_48);
-    let __v_50: G = (__v_46 + __v_49);
-    let __v_51: G = (__v_45 + __v_50);
-    let __v_52: G = (__v_44 + __v_51);
-    let __v_53: G = G::from_bool((__v_52 == G::ZERO));
-    let __v_54: G = (__v_42 + __v_43);
-    let __v_55: G = (__v_41 + __v_54);
-    let __v_56: G = (__v_40 + __v_55);
-    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
-    let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
-    let __v_58: G = G::from_u8(__gb[0]);
-    let __v_59: G = G::from_u8(__gb[1]);
-    let __v_60: G = G::from_u8(__gb[2]);
-    let __v_61: G = G::from_u8(__gb[3]);
-    let __v_62: G = G::from_u8(__gb[4]);
-    let __v_63: G = G::from_u8(__gb[5]);
-    let __v_64: G = G::from_u8(__gb[6]);
-    let __v_65: G = G::from_u8(__gb[7]);
-    if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66: G = G::from_u64(1020);
-    let __v_67: G = (__v_65 - __v_66);
-    let __v_68: G = (__v_64 + __v_67);
-    let __v_69: G = (__v_63 + __v_68);
-    let __v_70: G = (__v_62 + __v_69);
-    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
-    let __v_72: G = (__v_60 + __v_61);
-    let __v_73: G = (__v_59 + __v_72);
-    let __v_74: G = (__v_58 + __v_73);
-    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
-    let __v_76: G = G::from_u64(0);
-    let __v_77: G = G::from_u64(256);
-    let __v_78: G = (__v_77 * __v_5);
-    let __v_79: G = G::from_u64(65536);
-    let __v_80: G = (__v_79 * __v_6);
-    let __v_81: G = G::from_u64(16777216);
-    let __v_82: G = (__v_81 * __v_7);
-    let __v_83: G = G::from_u64(4294967296);
-    let __v_84: G = (__v_83 * __v_8);
-    let __v_85: G = G::from_u64(1099511627776);
-    let __v_86: G = (__v_85 * __v_9);
-    let __v_87: G = G::from_u64(281474976710656);
-    let __v_88: G = (__v_87 * __v_10);
-    let __v_89: G = G::from_u64(72057594037927936);
-    let __v_90: G = (__v_89 * __v_11);
-    let __v_91: G = (__v_88 + __v_90);
-    let __v_92: G = (__v_86 + __v_91);
-    let __v_93: G = (__v_84 + __v_92);
-    let __v_94: G = (__v_82 + __v_93);
-    let __v_95: G = (__v_80 + __v_94);
-    let __v_96: G = (__v_78 + __v_95);
-    let __v_97: G = (__v_4 + __v_96);
-    if (__v_97 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
-    }
-    let __v_98: G = G::from_u64(1);
-    let __v_99: G = G::from_u64(1);
-    let __v_100: G = (__v_99 - __v_21);
-    let __v_101: G = (__v_17 * __v_100);
-    let __v_102: G = (__v_98 - __v_101);
-    let __v_103: G = G::from_u64(1);
-    if (__v_102 != __v_103) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
-    }
-    let __v_104: G = G::from_u64(0);
-    let __v_105: G = G::from_u64(256);
-    let __v_106: G = (__v_105 * __v_23);
-    let __v_107: G = G::from_u64(65536);
-    let __v_108: G = (__v_107 * __v_24);
-    let __v_109: G = G::from_u64(16777216);
-    let __v_110: G = (__v_109 * __v_25);
-    let __v_111: G = G::from_u64(4294967296);
-    let __v_112: G = (__v_111 * __v_26);
-    let __v_113: G = G::from_u64(1099511627776);
-    let __v_114: G = (__v_113 * __v_27);
-    let __v_115: G = G::from_u64(281474976710656);
-    let __v_116: G = (__v_115 * __v_28);
-    let __v_117: G = G::from_u64(72057594037927936);
-    let __v_118: G = (__v_117 * __v_29);
-    let __v_119: G = (__v_116 + __v_118);
-    let __v_120: G = (__v_114 + __v_119);
-    let __v_121: G = (__v_112 + __v_120);
-    let __v_122: G = (__v_110 + __v_121);
-    let __v_123: G = (__v_108 + __v_122);
-    let __v_124: G = (__v_106 + __v_123);
-    let __v_125: G = (__v_22 + __v_124);
-    if (__v_125 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
-    }
-    let __v_126: G = G::from_u64(1);
-    let __v_127: G = G::from_u64(1);
-    let __v_128: G = (__v_127 - __v_39);
-    let __v_129: G = (__v_35 * __v_128);
-    let __v_130: G = (__v_126 - __v_129);
-    let __v_131: G = G::from_u64(1);
-    if (__v_130 != __v_131) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
-    }
-    let __v_132: G = G::from_u64(0);
-    let __v_133: G = G::from_u64(256);
-    let __v_134: G = (__v_133 * __v_41);
-    let __v_135: G = G::from_u64(65536);
-    let __v_136: G = (__v_135 * __v_42);
-    let __v_137: G = G::from_u64(16777216);
-    let __v_138: G = (__v_137 * __v_43);
-    let __v_139: G = G::from_u64(4294967296);
-    let __v_140: G = (__v_139 * __v_44);
-    let __v_141: G = G::from_u64(1099511627776);
-    let __v_142: G = (__v_141 * __v_45);
-    let __v_143: G = G::from_u64(281474976710656);
-    let __v_144: G = (__v_143 * __v_46);
-    let __v_145: G = G::from_u64(72057594037927936);
-    let __v_146: G = (__v_145 * __v_47);
-    let __v_147: G = (__v_144 + __v_146);
-    let __v_148: G = (__v_142 + __v_147);
-    let __v_149: G = (__v_140 + __v_148);
-    let __v_150: G = (__v_138 + __v_149);
-    let __v_151: G = (__v_136 + __v_150);
-    let __v_152: G = (__v_134 + __v_151);
-    let __v_153: G = (__v_40 + __v_152);
-    if (__v_153 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
-    }
-    let __v_154: G = G::from_u64(1);
-    let __v_155: G = G::from_u64(1);
-    let __v_156: G = (__v_155 - __v_57);
-    let __v_157: G = (__v_53 * __v_156);
-    let __v_158: G = (__v_154 - __v_157);
-    let __v_159: G = G::from_u64(1);
-    if (__v_158 != __v_159) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
+    let __v_32: G = (__v_27 * __v_31);
+    let __v_33: G = G::from_u64(0);
+    if (__v_32 != __v_33) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_33.as_canonical_u64(), msg: None });
     }
-    let __v_160: G = G::from_u64(0);
-    let __v_161: G = G::from_u64(256);
-    let __v_162: G = (__v_161 * __v_59);
-    let __v_163: G = G::from_u64(65536);
-    let __v_164: G = (__v_163 * __v_60);
-    let __v_165: G = G::from_u64(16777216);
-    let __v_166: G = (__v_165 * __v_61);
-    let __v_167: G = G::from_u64(4294967296);
-    let __v_168: G = (__v_167 * __v_62);
-    let __v_169: G = G::from_u64(1099511627776);
-    let __v_170: G = (__v_169 * __v_63);
-    let __v_171: G = G::from_u64(281474976710656);
-    let __v_172: G = (__v_171 * __v_64);
-    let __v_173: G = G::from_u64(72057594037927936);
-    let __v_174: G = (__v_173 * __v_65);
-    let __v_175: G = (__v_172 + __v_174);
-    let __v_176: G = (__v_170 + __v_175);
-    let __v_177: G = (__v_168 + __v_176);
-    let __v_178: G = (__v_166 + __v_177);
-    let __v_179: G = (__v_164 + __v_178);
-    let __v_180: G = (__v_162 + __v_179);
-    let __v_181: G = (__v_58 + __v_180);
-    if (__v_181 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    let __v_34: G = (__v_28 * __v_31);
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: None });
     }
-    let __v_182: G = G::from_u64(1);
-    let __v_183: G = G::from_u64(1);
-    let __v_184: G = (__v_183 - __v_75);
-    let __v_185: G = (__v_71 * __v_184);
-    let __v_186: G = (__v_182 - __v_185);
-    let __v_187: G = G::from_u64(1);
-    if (__v_186 != __v_187) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
+    let __v_36: G = (__v_21 * __v_28);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = (__v_37 - __v_22);
+    let __v_39: G = (__v_38 * __v_28);
+    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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+    let __v_42: G = (__v_40 - __v_41);
+    let __v_43: G = G::from_bool((__v_42 == G::ZERO));
+    let __v_44: G = G::from_u64(1);
+    if (__v_43 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: None });
     }
-    let __v_188: G = G::from_u64(1);
-    let __v_189: G = G::from_u64(1);
-    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_138] = [__v_194];
-    if let Some(result) = record.function_queries[138].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; 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 { let __r = record.function_queries[132].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+    let __ret: [G; OUT_135] = [__v_45];
+    if !unconstrained { record.virt += record.function_queries[135].weight(); } record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_139: usize = 6;
-const IN_139: usize = 6;
-const OUT_139: usize = 3;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_136: usize = 11;
+const IN_136: usize = 11;
+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_139], ExecError> {
+) -> Result<[G; OUT_136], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_6: G = __loaded[0];
-    let __v_7: G = __loaded[1];
-    let __v_8: G = __loaded[2];
-    let __v_9: G = __loaded[3];
-    let __v_10: G = __loaded[4];
-    let __v_11: G = __loaded[5];
-    let __v_12: G = __loaded[6];
-    match __v_6.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-        if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_7.as_canonical_u64() {
-          _ => {
-            let __v_13: G = (__v_7 - __v_2);
-            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
-            match __v_14.as_canonical_u64() {
-              1u64 => {
-                let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-                let __v_16: G = __r_arr[0];
-                let __v_17: G = __r_arr[1];
-                let __v_18: G = (__v_16 * __v_10);
-                let __v_19: G = G::from_u64(7);
-                let __v_20: G = (__v_17 * __v_11);
-                let __v_21: G = (__v_19 * __v_20);
-                let __v_22: G = (__v_18 + __v_21);
-                let __v_23: G = (__v_16 * __v_11);
-                let __v_24: G = (__v_17 * __v_10);
-                let __v_25: G = (__v_23 + __v_24);
-                let __v_26: G = (__v_0 + __v_22);
-                let __v_27: G = (__v_1 + __v_25);
-                let __ret: [G; OUT_139] = [__v_26, __v_27, __v_12];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __ret: [G; OUT_139] = [__v_0, __v_1, __v_5];
-                if let Some(result) = record.function_queries[139].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = G::from_u64(0);
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8, __v_11]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(1);
+    let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8, __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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_4]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = (__v_5 * __v_15);
+    let __v_18: G = G::from_u64(7);
+    let __v_19: G = (__v_6 * __v_16);
+    let __v_20: G = (__v_18 * __v_19);
+    let __v_21: G = (__v_17 + __v_20);
+    let __v_22: G = (__v_5 * __v_16);
+    let __v_23: G = (__v_6 * __v_15);
+    let __v_24: G = (__v_22 + __v_23);
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+    let __ret: [G; OUT_136] = [__v_26];
+    if !unconstrained { record.virt += record.function_queries[136].weight(); } record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_140: usize = 9;
-const IN_140: usize = 9;
-const OUT_140: usize = 2;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_137: usize = 13;
+const IN_137: usize = 13;
+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_140], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -12906,376 +13270,51 @@ fn aiur_fn_140(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
-    let __v_9: G = __loaded[0];
-    let __v_10: G = __loaded[1];
-    let __v_11: G = __loaded[2];
-    let __v_12: G = __loaded[3];
-    let __v_13: G = __loaded[4];
-    match __v_9.as_canonical_u64() {
-      1u64 => {
-        let __v_14: G = (__v_6 - __v_8);
-        let __v_15: G = G::from_bool((__v_14 == G::ZERO));
-        let __v_16: G = G::from_u64(1);
-        if (__v_15 != __v_16) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-        let __v_17: G = __r_arr[0];
-        let __v_18: G = G::from_u64(0);
-        if (__v_17 != __v_18) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
-        }
-        let __ret: [G; OUT_140] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_14: G = __loaded[0];
-        let __v_15: G = __loaded[1];
-        let __v_16: G = __loaded[2];
-        let __v_17: G = __loaded[3];
-        match __v_14.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_18: G = __loaded[0];
-            let __v_19: G = __loaded[1];
-            let __v_20: G = __loaded[2];
-            match __v_18.as_canonical_u64() {
-              0u64 => {
-                match __v_10.as_canonical_u64() {
-                  _ => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_21: G = __loaded[0];
-                    let __v_22: G = __loaded[1];
-                    let __v_23: G = __loaded[2];
-                    match __v_21.as_canonical_u64() {
-                      0u64 => {
-                        let __v_24: G = G::from_u64(1);
-                        let __v_25: G = (__v_6 - __v_24);
-                        let __v_26: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                        let __v_27: G = __r_arr[0];
-                        let __v_28: G = __r_arr[1];
-                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_22.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_0, __v_1, __v_27, __v_28];
-  },
-  _ => {
-    break '__mc_0 [__v_27, __v_28, __v_0, __v_1];
-  },
-}
- };
-                        let __v_29: G = __mc_out___mc_0[0];
-                        let __v_30: G = __mc_out___mc_0[1];
-                        let __v_31: G = __mc_out___mc_0[2];
-                        let __v_32: G = __mc_out___mc_0[3];
-                        let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
-                        let __v_33: G = G::from_u8(__gb[0]);
-                        let __v_34: G = G::from_u8(__gb[1]);
-                        let __v_35: G = G::from_u8(__gb[2]);
-                        let __v_36: G = G::from_u8(__gb[3]);
-                        let __v_37: G = G::from_u8(__gb[4]);
-                        let __v_38: G = G::from_u8(__gb[5]);
-                        let __v_39: G = G::from_u8(__gb[6]);
-                        let __v_40: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
-                        let __v_41: G = G::from_u64(1020);
-                        let __v_42: G = (__v_40 - __v_41);
-                        let __v_43: G = (__v_39 + __v_42);
-                        let __v_44: G = (__v_38 + __v_43);
-                        let __v_45: G = (__v_37 + __v_44);
-                        let __v_46: G = G::from_bool((__v_45 == G::ZERO));
-                        let __v_47: G = (__v_35 + __v_36);
-                        let __v_48: G = (__v_34 + __v_47);
-                        let __v_49: G = (__v_33 + __v_48);
-                        let __v_50: G = G::from_bool((__v_49 == G::ZERO));
-                        let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
-                        let __v_51: G = G::from_u8(__gb[0]);
-                        let __v_52: G = G::from_u8(__gb[1]);
-                        let __v_53: G = G::from_u8(__gb[2]);
-                        let __v_54: G = G::from_u8(__gb[3]);
-                        let __v_55: G = G::from_u8(__gb[4]);
-                        let __v_56: G = G::from_u8(__gb[5]);
-                        let __v_57: G = G::from_u8(__gb[6]);
-                        let __v_58: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_51; let __vj = __v_52; 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_53; let __vj = __v_54; 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_55; let __vj = __v_56; 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_57; let __vj = __v_58; 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_59: G = G::from_u64(1020);
-                        let __v_60: G = (__v_58 - __v_59);
-                        let __v_61: G = (__v_57 + __v_60);
-                        let __v_62: G = (__v_56 + __v_61);
-                        let __v_63: G = (__v_55 + __v_62);
-                        let __v_64: G = G::from_bool((__v_63 == G::ZERO));
-                        let __v_65: G = (__v_53 + __v_54);
-                        let __v_66: G = (__v_52 + __v_65);
-                        let __v_67: G = (__v_51 + __v_66);
-                        let __v_68: G = G::from_bool((__v_67 == G::ZERO));
-                        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
-                        let __v_69: G = G::from_u8(__gb[0]);
-                        let __v_70: G = G::from_u8(__gb[1]);
-                        let __v_71: G = G::from_u8(__gb[2]);
-                        let __v_72: G = G::from_u8(__gb[3]);
-                        let __v_73: G = G::from_u8(__gb[4]);
-                        let __v_74: G = G::from_u8(__gb[5]);
-                        let __v_75: G = G::from_u8(__gb[6]);
-                        let __v_76: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_69; let __vj = __v_70; 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_71; let __vj = __v_72; 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_73; let __vj = __v_74; 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_75; let __vj = __v_76; 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_77: G = G::from_u64(1020);
-                        let __v_78: G = (__v_76 - __v_77);
-                        let __v_79: G = (__v_75 + __v_78);
-                        let __v_80: G = (__v_74 + __v_79);
-                        let __v_81: G = (__v_73 + __v_80);
-                        let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                        let __v_83: G = (__v_71 + __v_72);
-                        let __v_84: G = (__v_70 + __v_83);
-                        let __v_85: G = (__v_69 + __v_84);
-                        let __v_86: G = G::from_bool((__v_85 == G::ZERO));
-                        let __gb: [u8; 8] = __v_32.as_canonical_u64().to_le_bytes();
-                        let __v_87: G = G::from_u8(__gb[0]);
-                        let __v_88: G = G::from_u8(__gb[1]);
-                        let __v_89: G = G::from_u8(__gb[2]);
-                        let __v_90: G = G::from_u8(__gb[3]);
-                        let __v_91: G = G::from_u8(__gb[4]);
-                        let __v_92: G = G::from_u8(__gb[5]);
-                        let __v_93: G = G::from_u8(__gb[6]);
-                        let __v_94: G = G::from_u8(__gb[7]);
-                        if !unconstrained { let __vi = __v_87; let __vj = __v_88; 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_89; let __vj = __v_90; 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_91; let __vj = __v_92; 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_93; let __vj = __v_94; 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_95: G = G::from_u64(1020);
-                        let __v_96: G = (__v_94 - __v_95);
-                        let __v_97: G = (__v_93 + __v_96);
-                        let __v_98: G = (__v_92 + __v_97);
-                        let __v_99: G = (__v_91 + __v_98);
-                        let __v_100: G = G::from_bool((__v_99 == G::ZERO));
-                        let __v_101: G = (__v_89 + __v_90);
-                        let __v_102: G = (__v_88 + __v_101);
-                        let __v_103: G = (__v_87 + __v_102);
-                        let __v_104: G = G::from_bool((__v_103 == G::ZERO));
-                        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_113(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } } else { aiur_fn_113(__args, record, io_buffer, __cu)? } };
-                        let __v_105: G = __r_arr[0];
-                        let __v_106: G = __r_arr[1];
-                        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_105, __v_106, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_139(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } } else { aiur_fn_139(__args, record, io_buffer, __cu)? } };
-                        let __v_107: G = __r_arr[0];
-                        let __v_108: G = __r_arr[1];
-                        let __v_109: G = __r_arr[2];
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_110: G = __r_arr[0];
-                        let __v_111: G = G::from_u64(1);
-                        if (__v_110 != __v_111) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_110.as_canonical_u64(), rhs: __v_111.as_canonical_u64(), msg: None });
-                        }
-                        let __v_112: G = G::from_u64(0);
-                        let __v_113: G = G::from_u64(0);
-                        let __v_114: G = G::from_u64(256);
-                        let __v_115: G = (__v_114 * __v_34);
-                        let __v_116: G = G::from_u64(65536);
-                        let __v_117: G = (__v_116 * __v_35);
-                        let __v_118: G = G::from_u64(16777216);
-                        let __v_119: G = (__v_118 * __v_36);
-                        let __v_120: G = G::from_u64(4294967296);
-                        let __v_121: G = (__v_120 * __v_37);
-                        let __v_122: G = G::from_u64(1099511627776);
-                        let __v_123: G = (__v_122 * __v_38);
-                        let __v_124: G = G::from_u64(281474976710656);
-                        let __v_125: G = (__v_124 * __v_39);
-                        let __v_126: G = G::from_u64(72057594037927936);
-                        let __v_127: G = (__v_126 * __v_40);
-                        let __v_128: G = (__v_125 + __v_127);
-                        let __v_129: G = (__v_123 + __v_128);
-                        let __v_130: G = (__v_121 + __v_129);
-                        let __v_131: G = (__v_119 + __v_130);
-                        let __v_132: G = (__v_117 + __v_131);
-                        let __v_133: G = (__v_115 + __v_132);
-                        let __v_134: G = (__v_33 + __v_133);
-                        if (__v_134 != __v_29) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
-                        }
-                        let __v_135: G = G::from_u64(1);
-                        let __v_136: G = G::from_u64(1);
-                        let __v_137: G = (__v_136 - __v_50);
-                        let __v_138: G = (__v_46 * __v_137);
-                        let __v_139: G = (__v_135 - __v_138);
-                        let __v_140: G = G::from_u64(1);
-                        if (__v_139 != __v_140) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: None });
-                        }
-                        let __v_141: G = G::from_u64(0);
-                        let __v_142: G = G::from_u64(256);
-                        let __v_143: G = (__v_142 * __v_52);
-                        let __v_144: G = G::from_u64(65536);
-                        let __v_145: G = (__v_144 * __v_53);
-                        let __v_146: G = G::from_u64(16777216);
-                        let __v_147: G = (__v_146 * __v_54);
-                        let __v_148: G = G::from_u64(4294967296);
-                        let __v_149: G = (__v_148 * __v_55);
-                        let __v_150: G = G::from_u64(1099511627776);
-                        let __v_151: G = (__v_150 * __v_56);
-                        let __v_152: G = G::from_u64(281474976710656);
-                        let __v_153: G = (__v_152 * __v_57);
-                        let __v_154: G = G::from_u64(72057594037927936);
-                        let __v_155: G = (__v_154 * __v_58);
-                        let __v_156: G = (__v_153 + __v_155);
-                        let __v_157: G = (__v_151 + __v_156);
-                        let __v_158: G = (__v_149 + __v_157);
-                        let __v_159: G = (__v_147 + __v_158);
-                        let __v_160: G = (__v_145 + __v_159);
-                        let __v_161: G = (__v_143 + __v_160);
-                        let __v_162: G = (__v_51 + __v_161);
-                        if (__v_162 != __v_30) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
-                        }
-                        let __v_163: G = G::from_u64(1);
-                        let __v_164: G = G::from_u64(1);
-                        let __v_165: G = (__v_164 - __v_68);
-                        let __v_166: G = (__v_64 * __v_165);
-                        let __v_167: G = (__v_163 - __v_166);
-                        let __v_168: G = G::from_u64(1);
-                        if (__v_167 != __v_168) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_168.as_canonical_u64(), msg: None });
-                        }
-                        let __v_169: G = G::from_u64(0);
-                        let __v_170: G = G::from_u64(256);
-                        let __v_171: G = (__v_170 * __v_70);
-                        let __v_172: G = G::from_u64(65536);
-                        let __v_173: G = (__v_172 * __v_71);
-                        let __v_174: G = G::from_u64(16777216);
-                        let __v_175: G = (__v_174 * __v_72);
-                        let __v_176: G = G::from_u64(4294967296);
-                        let __v_177: G = (__v_176 * __v_73);
-                        let __v_178: G = G::from_u64(1099511627776);
-                        let __v_179: G = (__v_178 * __v_74);
-                        let __v_180: G = G::from_u64(281474976710656);
-                        let __v_181: G = (__v_180 * __v_75);
-                        let __v_182: G = G::from_u64(72057594037927936);
-                        let __v_183: G = (__v_182 * __v_76);
-                        let __v_184: G = (__v_181 + __v_183);
-                        let __v_185: G = (__v_179 + __v_184);
-                        let __v_186: G = (__v_177 + __v_185);
-                        let __v_187: G = (__v_175 + __v_186);
-                        let __v_188: G = (__v_173 + __v_187);
-                        let __v_189: G = (__v_171 + __v_188);
-                        let __v_190: G = (__v_69 + __v_189);
-                        if (__v_190 != __v_31) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_190.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
-                        }
-                        let __v_191: G = G::from_u64(1);
-                        let __v_192: G = G::from_u64(1);
-                        let __v_193: G = (__v_192 - __v_86);
-                        let __v_194: G = (__v_82 * __v_193);
-                        let __v_195: G = (__v_191 - __v_194);
-                        let __v_196: G = G::from_u64(1);
-                        if (__v_195 != __v_196) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None });
-                        }
-                        let __v_197: G = G::from_u64(0);
-                        let __v_198: G = G::from_u64(256);
-                        let __v_199: G = (__v_198 * __v_88);
-                        let __v_200: G = G::from_u64(65536);
-                        let __v_201: G = (__v_200 * __v_89);
-                        let __v_202: G = G::from_u64(16777216);
-                        let __v_203: G = (__v_202 * __v_90);
-                        let __v_204: G = G::from_u64(4294967296);
-                        let __v_205: G = (__v_204 * __v_91);
-                        let __v_206: G = G::from_u64(1099511627776);
-                        let __v_207: G = (__v_206 * __v_92);
-                        let __v_208: G = G::from_u64(281474976710656);
-                        let __v_209: G = (__v_208 * __v_93);
-                        let __v_210: G = G::from_u64(72057594037927936);
-                        let __v_211: G = (__v_210 * __v_94);
-                        let __v_212: G = (__v_209 + __v_211);
-                        let __v_213: G = (__v_207 + __v_212);
-                        let __v_214: G = (__v_205 + __v_213);
-                        let __v_215: G = (__v_203 + __v_214);
-                        let __v_216: G = (__v_201 + __v_215);
-                        let __v_217: G = (__v_199 + __v_216);
-                        let __v_218: G = (__v_87 + __v_217);
-                        if (__v_218 != __v_32) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-                        }
-                        let __v_219: G = G::from_u64(1);
-                        let __v_220: G = G::from_u64(1);
-                        let __v_221: G = (__v_220 - __v_104);
-                        let __v_222: G = (__v_100 * __v_221);
-                        let __v_223: G = (__v_219 - __v_222);
-                        let __v_224: G = G::from_u64(1);
-                        if (__v_223 != __v_224) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_224.as_canonical_u64(), msg: None });
-                        }
-                        let __v_225: G = G::from_u64(1);
-                        let __v_226: G = G::from_u64(1);
-                        let __v_227: G = { let __values: [G; 10] = [__v_225, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226, __v_226]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_228: G = { let __values: [G; 10] = [__v_197, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_227]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_229: G = { let __values: [G; 10] = [__v_169, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_230: G = { let __values: [G; 10] = [__v_141, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_231: G = { let __values: [G; 10] = [__v_113, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_232: G = G::from_u64(1);
-                        let __v_233: G = G::from_u64(1);
-                        let __v_234: G = { let __values: [G; 3] = [__v_232, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_235: G = { let __values: [G; 3] = [__v_112, __v_231, __v_234]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_236: G = G::from_u64(0);
-                        let __v_237: G = G::from_u64(1);
-                        let __v_238: G = G::from_u64(1);
-                        let __v_239: G = { let __values: [G; 3] = [__v_237, __v_238, __v_238]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __v_240: G = { let __values: [G; 3] = [__v_236, __v_25, __v_239]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_19, __v_235, __v_240, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                        let __v_241: G = __r_arr[0];
-                        let __v_242: G = G::from_u64(1);
-                        if (__v_241 != __v_242) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_107, __v_108, __v_17, __v_20, __v_13, __v_23, __v_25, __v_109, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
-                        let __v_243: G = __r_arr[0];
-                        let __v_244: G = __r_arr[1];
-                        let __ret: [G; OUT_140] = [__v_243, __v_244];
-                        if let Some(result) = record.function_queries[140].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                        return Ok(__ret);
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64()));
-                      },
-                    }
-                  },
-                }
-              },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64()));
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
-          },
-        }
+        let __ret: [G; OUT_137] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; 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 { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = (__v_4 + __v_18);
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_5 - __v_20);
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __ret: [G; OUT_137] = [__v_22];
+        if !unconstrained { record.virt += record.function_queries[137].weight(); } record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_141: usize = 25;
-const IN_141: usize = 25;
-const OUT_141: usize = 1;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+const INPUT_SIZE_138: usize = 13;
+const IN_138: usize = 13;
+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_141], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13289,184 +13328,50 @@ fn aiur_fn_141(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    match __v_1.as_canonical_u64() {
+    match __v_5.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_138] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
       _ => {
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_124(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } } else { aiur_fn_124(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = G::from_u64(0);
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        match __v_29.as_canonical_u64() {
-          _ => {
-            let __v_31: G = G::from_u64(0);
-            let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_25, __v_0, __v_20, __v_19, __v_31, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = G::from_u64(1);
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = __r_arr[1];
-            match __v_34.as_canonical_u64() {
-              _ => {
-                let __v_36: G = G::from_u64(0);
-                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_32, __v_0, __v_20, __v_19, __v_36, __v_18, __v_15, __v_16, __v_17, __v_34, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_130(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } } else { aiur_fn_130(__args, record, io_buffer, __cu)? } };
-                let __v_37: G = __r_arr[0];
-                let __v_38: G = G::from_u64(2);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_39: G = __r_arr[0];
-                let __v_40: G = __r_arr[1];
-                match __v_39.as_canonical_u64() {
-                  _ => {
-                    let __v_41: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_37, __v_0, __v_20, __v_19, __v_41, __v_18, __v_15, __v_16, __v_17, __v_39, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } };
-                    let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_42, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_133(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } } else { aiur_fn_133(__args, record, io_buffer, __cu)? } };
-                    let __v_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_43, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_126(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } } else { aiur_fn_126(__args, record, io_buffer, __cu)? } };
-                    let __v_44: G = __r_arr[0];
-                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_43.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-                    let __v_45: G = __loaded[0];
-                    let __v_46: G = __loaded[1];
-                    let __v_47: G = __loaded[2];
-                    let __v_48: G = __loaded[3];
-                    let __v_49: G = __loaded[4];
-                    let __v_50: G = __loaded[5];
-                    let __v_51: G = __loaded[6];
-                    match __v_45.as_canonical_u64() {
-                      0u64 => {
-                        match __v_46.as_canonical_u64() {
-                          _ => {
-                            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_49, __v_50, __v_21, __v_22, __v_2, __v_0, __v_20, __v_51, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_140(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } } else { aiur_fn_140(__args, record, io_buffer, __cu)? } };
-                            let __v_52: G = __r_arr[0];
-                            let __v_53: G = __r_arr[1];
-                            let __v_54: G = G::from_u64(0);
-                            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_23, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                            let __v_55: G = __r_arr[0];
-                            let __v_56: G = __r_arr[1];
-                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-                            let __v_57: G = __r_arr[0];
-                            let __v_58: G = (__v_57 - __v_24);
-                            let __v_59: G = G::from_bool((__v_58 == G::ZERO));
-                            let __v_60: G = G::from_u64(1);
-                            if (__v_59 != __v_60) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                            let __v_61: G = __r_arr[0];
-                            let __v_62: G = G::from_u64(3);
-                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } };
-                            let __v_63: G = __r_arr[0];
-                            let __v_64: G = (__v_62 + __v_63);
-                            let __v_65: G = (__v_61 - __v_64);
-                            let __v_66: G = G::from_bool((__v_65 == G::ZERO));
-                            let __v_67: G = G::from_u64(1);
-                            if (__v_66 != __v_67) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_68: G = __r_arr[0];
-                            let __v_69: G = (__v_68 - __v_18);
-                            let __v_70: G = G::from_bool((__v_69 == G::ZERO));
-                            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: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_10, __v_29, __v_27, __v_0, __v_30, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_72: G = __r_arr[0];
-                            let __v_73: G = G::from_u64(1);
-                            if (__v_72 != __v_73) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_74: G = __r_arr[0];
-                            let __v_75: G = (__v_74 - __v_18);
-                            let __v_76: G = G::from_bool((__v_75 == G::ZERO));
-                            let __v_77: G = G::from_u64(1);
-                            if (__v_76 != __v_77) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_11, __v_34, __v_27, __v_0, __v_35, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_78: G = __r_arr[0];
-                            let __v_79: G = G::from_u64(1);
-                            if (__v_78 != __v_79) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                            let __v_80: G = __r_arr[0];
-                            let __v_81: G = (__v_80 - __v_18);
-                            let __v_82: G = G::from_bool((__v_81 == G::ZERO));
-                            let __v_83: G = G::from_u64(1);
-                            if (__v_82 != __v_83) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64(), msg: None });
-                            }
-                            let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_12, __v_39, __v_27, __v_0, __v_40, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_110(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } } else { aiur_fn_110(__args, record, io_buffer, __cu)? } };
-                            let __v_84: G = __r_arr[0];
-                            let __v_85: G = G::from_u64(1);
-                            if (__v_84 != __v_85) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_85.as_canonical_u64(), msg: None });
-                            }
-                            let __v_86: G = (__v_46 - __v_20);
-                            let __v_87: G = G::from_bool((__v_86 == G::ZERO));
-                            let __v_88: G = G::from_u64(1);
-                            if (__v_87 != __v_88) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
-                            }
-                            let __v_89: G = (__v_55 - __v_52);
-                            let __v_90: G = G::from_bool((__v_89 == G::ZERO));
-                            let __v_91: G = (__v_56 - __v_53);
-                            let __v_92: G = G::from_bool((__v_91 == G::ZERO));
-                            let __v_93: G = (__v_90 * __v_92);
-                            let __v_94: G = G::from_u64(1);
-                            if (__v_93 != __v_94) {
-                              return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64(), msg: None });
-                            }
-                            let __v_95: G = G::from_u64(1);
-                            let __ret: [G; OUT_141] = [__v_95];
-                            if let Some(result) = record.function_queries[141].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                            return Ok(__ret);
-                          },
-                        }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64()));
-                      },
-                    }
-                  },
-                }
-              },
-            }
-          },
-        }
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_6, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = (__v_13 + __v_3);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_9, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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 __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_10, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_16, __v_17]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; 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 { let __r = record.function_queries[135].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = G::from_u64(1);
+        let __v_21: G = (__v_4 + __v_20);
+        let __v_22: G = G::from_u64(1);
+        let __v_23: G = (__v_5 - __v_22);
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_138] = [__v_24];
+        if !unconstrained { record.virt += record.function_queries[138].weight(); } record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_142: usize = 25;
-const IN_142: usize = 25;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+const INPUT_SIZE_139: usize = 15;
+const IN_139: usize = 15;
+const OUT_139: usize = 1;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_142], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13482,58 +13387,70 @@ fn aiur_fn_142(
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_25: G = __loaded[0];
-    let __v_26: G = __loaded[1];
-    let __v_27: G = __loaded[2];
-    let __v_28: G = __loaded[3];
-    match __v_25.as_canonical_u64() {
-      1u64 => {
-        let __v_29: G = G::from_u64(1);
-        let __ret: [G; OUT_142] = [__v_29];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = __r_arr[1];
-        let __v_31: G = __r_arr[2];
-        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_141(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } } else { aiur_fn_141(__args, record, io_buffer, __cu)? } };
-        let __v_32: G = __r_arr[0];
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __ret: [G; OUT_142] = [__v_33];
-        if let Some(result) = record.function_queries[142].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_139] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_4]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+        let __v_16: G = __r_arr[1];
+        match __v_15.as_canonical_u64() {
+          0u64 => {
+            let __v_17: G = G::from_u64(1);
+            let __v_18: G = (__v_4 + __v_17);
+            let __v_19: G = G::from_u64(1);
+            let __v_20: G = (__v_5 - __v_19);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_21];
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+            let __v_18: G = (__v_17 + __v_3);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_11, __v_6]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_12, __v_6]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; 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 { let __r = record.function_queries[136].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = G::from_u64(1);
+            let __v_23: G = (__v_4 + __v_22);
+            let __v_24: G = G::from_u64(1);
+            let __v_25: G = (__v_5 - __v_24);
+            let __v_26: G = G::from_u64(1);
+            let __v_27: G = (__v_6 + __v_26);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+            let __ret: [G; OUT_139] = [__v_28];
+            if !unconstrained { record.virt += record.function_queries[139].weight(); } record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_143: usize = 31;
-const IN_143: usize = 31;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_140: usize = 15;
+const IN_140: usize = 15;
+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_143], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -13549,234 +13466,130 @@ fn aiur_fn_143(
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    match __v_6.as_canonical_u64() {
-      _ => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_31: G = __r_arr[0];
-        let __v_32: G = G::from_u64(1);
-        let __v_33: G = G::from_u64(1);
-        let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
-  0u64 => {
-    break '__mc_0 [__v_34];
-  },
-  1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    break '__mc_0 [__v_35];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
-  },
-}
- };
-        let __v_35: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_36: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __v_40: G = G::from_u64(1);
-        let __v_41: G = G::from_u64(1);
-        let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-        let __v_43: G = __r_arr[0];
-        let __v_44: G = __r_arr[1];
-        let __v_45: G = __r_arr[2];
-        let __v_46: G = __r_arr[3];
-        let __v_47: G = __r_arr[4];
-        let __v_48: G = __r_arr[5];
-        let __v_49: G = __r_arr[6];
-        let __v_50: G = __r_arr[7];
-        let __v_51: G = __r_arr[8];
-        let __v_52: G = __r_arr[9];
-        let __v_53: G = __r_arr[10];
-        let __v_54: G = __r_arr[11];
-        let __v_55: G = __r_arr[12];
-        let __v_56: G = __r_arr[13];
-        let __v_57: G = __r_arr[14];
-        let __v_58: G = __r_arr[15];
-        let __v_59: G = __r_arr[16];
-        let __v_60: G = __r_arr[17];
-        let __v_61: G = G::from_u64(256);
-        let __v_62: G = (__v_61 * __v_44);
-        let __v_63: G = G::from_u64(65536);
-        let __v_64: G = (__v_63 * __v_45);
-        let __v_65: G = G::from_u64(16777216);
-        let __v_66: G = (__v_65 * __v_46);
-        let __v_67: G = G::from_u64(4294967296);
-        let __v_68: G = (__v_67 * __v_47);
-        let __v_69: G = G::from_u64(1099511627776);
-        let __v_70: G = (__v_69 * __v_48);
-        let __v_71: G = G::from_u64(281474976710656);
-        let __v_72: G = (__v_71 * __v_49);
-        let __v_73: G = G::from_u64(72057594037927936);
-        let __v_74: G = (__v_73 * __v_50);
-        let __v_75: G = (__v_72 + __v_74);
-        let __v_76: G = (__v_70 + __v_75);
-        let __v_77: G = (__v_68 + __v_76);
-        let __v_78: G = (__v_66 + __v_77);
-        let __v_79: G = (__v_64 + __v_78);
-        let __v_80: G = (__v_62 + __v_79);
-        let __v_81: G = (__v_43 + __v_80);
-        let __v_82: G = G::from_u64(256);
-        let __v_83: G = (__v_82 * __v_52);
-        let __v_84: G = G::from_u64(65536);
-        let __v_85: G = (__v_84 * __v_53);
-        let __v_86: G = G::from_u64(16777216);
-        let __v_87: G = (__v_86 * __v_54);
-        let __v_88: G = G::from_u64(4294967296);
-        let __v_89: G = (__v_88 * __v_55);
-        let __v_90: G = G::from_u64(1099511627776);
-        let __v_91: G = (__v_90 * __v_56);
-        let __v_92: G = G::from_u64(281474976710656);
-        let __v_93: G = (__v_92 * __v_57);
-        let __v_94: G = G::from_u64(72057594037927936);
-        let __v_95: G = (__v_94 * __v_58);
-        let __v_96: G = (__v_93 + __v_95);
-        let __v_97: G = (__v_91 + __v_96);
-        let __v_98: G = (__v_89 + __v_97);
-        let __v_99: G = (__v_87 + __v_98);
-        let __v_100: G = (__v_85 + __v_99);
-        let __v_101: G = (__v_83 + __v_100);
-        let __v_102: G = (__v_51 + __v_101);
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-        let __v_103: G = __r_arr[0];
-        let __v_104: G = __r_arr[1];
-        let __v_105: G = G::from_u64(1);
-        let __v_106: G = G::from_u64(1);
-        let __v_107: G = { let __values: [G; 3] = [__v_105, __v_106, __v_106]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-        let __v_108: G = __r_arr[0];
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_104, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-        let __v_109: G = __r_arr[0];
-        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_109, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-        let __v_110: G = __r_arr[0];
-        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_110, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-        let __v_111: G = __r_arr[0];
-        let __v_112: G = __r_arr[1];
-        let __v_113: G = (__v_31 + __v_27);
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-        let __v_114: G = __r_arr[0];
-        let __v_115: G = (__v_114 - __v_31);
-        let __v_116: G = G::from_bool((__v_115 == G::ZERO));
-        let __v_117: G = G::from_u64(1);
-        if (__v_116 != __v_117) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_116.as_canonical_u64(), rhs: __v_117.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_118: G = __r_arr[0];
-        let __v_119: G = (__v_118 - __v_28);
-        let __v_120: G = G::from_bool((__v_119 == G::ZERO));
-        let __v_121: G = G::from_u64(1);
-        if (__v_120 != __v_121) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_120.as_canonical_u64(), rhs: __v_121.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_122: G = __r_arr[0];
-        let __v_123: G = G::from_u64(1);
-        if (__v_122 != __v_123) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_123.as_canonical_u64(), msg: None });
-        }
-        let __v_124: G = G::from_u64(33);
-        let __v_125: G = { let __a_val = __v_113.as_canonical_u64(); let __b_val = __v_124.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-        let __v_126: G = G::from_u64(1);
-        if (__v_125 != __v_126) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_111, __v_112, __v_8, __v_81, __v_102, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_113, __v_103, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-        let __v_127: G = __r_arr[0];
-        let __ret: [G; OUT_143] = [__v_127];
-        if let Some(result) = record.function_queries[143].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_140] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
+      1u64 => {
+        let __v_15: G = G::from_u64(3);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_15]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        match __v_16.as_canonical_u64() {
+          _ => {
+            let __v_17: G = G::from_u64(0);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_6, __v_10, __v_5, __v_7, __v_17]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_142] = { let __args: [G; IN_142] = [__v_18]; 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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_16]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+            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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = (__v_20 - __v_21);
+            let __v_23: G = G::from_bool((__v_22 == G::ZERO));
+            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: None });
+            }
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; 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 { let __r = record.function_queries[139].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+            let __ret: [G; OUT_140] = [__v_27];
+            if !unconstrained { record.virt += record.function_queries[140].weight(); } record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
     }
   })
 }
 
-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_141: usize = 4;
+const IN_141: usize = 4;
+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_144], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_bool((__v_0 == G::ZERO));
-    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
-    let __v_4: G = (__v_2 * __v_3);
-    let __ret: [G; OUT_144] = [__v_4];
-    if let Some(result) = record.function_queries[144].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_141] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_3]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = (__v_5 + __v_1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 - __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 + __v_9);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1, __v_8, __v_10]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_141] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[141].weight(); } record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_145: usize = 1;
-const IN_145: usize = 1;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_142: usize = 1;
+const IN_142: usize = 1;
+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_145], ExecError> {
+) -> Result<[G; OUT_142], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
-    let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_145] = [__v_5];
-        if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_142] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
+        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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 __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_5.as_canonical_u64() {
-          1u64 => {
-            let __v_9: G = G::from_bool((__v_2 == G::ZERO));
-            let __v_10: G = G::from_bool((__v_3 == G::ZERO));
-            let __v_11: G = (__v_9 * __v_10);
-            let __ret: [G; OUT_145] = [__v_11];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+          0u64 => {
+            let __ret: [G; OUT_142] = [__v_4];
+            if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-            let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_145] = [__v_9];
-            if let Some(result) = record.function_queries[145].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_142] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[142].weight(); } record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
         }
@@ -13788,916 +13601,1417 @@ fn aiur_fn_145(
   })
 }
 
-const INPUT_SIZE_146: usize = 9;
-const IN_146: usize = 9;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_143: usize = 5;
+const IN_143: usize = 5;
+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_146], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(0);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(0);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_146] = [__v_24];
-    if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_143] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_4]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = (__v_3 - __v_7);
+            let __v_9: G = G::from_u64(1);
+            let __v_10: G = (__v_4 + __v_9);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_2, __v_8, __v_10]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+            let __ret: [G; OUT_143] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_4]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __v_9: G = (__v_8 + __v_1);
+            let __v_10: G = G::from_u64(1);
+            let __v_11: G = (__v_3 - __v_10);
+            let __v_12: G = G::from_u64(1);
+            let __v_13: G = (__v_4 + __v_12);
+            let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_0, __v_1, __v_2, __v_11, __v_13]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+            let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_143] = [__v_15];
+            if !unconstrained { record.virt += record.function_queries[143].weight(); } record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_147: usize = 33;
-const IN_147: usize = 33;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
+const INPUT_SIZE_144: usize = 5;
+const IN_144: usize = 5;
+const OUT_144: usize = 4;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_147], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_34: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_35: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_36: G = __r_arr[0];
-    let __ret: [G; OUT_147] = [__v_36];
-    if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_144] = [__v_1, __v_2, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __ret: [G; OUT_144] = [__v_3, __v_4, __v_1, __v_2];
+        if !unconstrained { record.virt += record.function_queries[144].weight(); } record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_148: usize = 2;
-const IN_148: usize = 2;
-const OUT_148: usize = 1;
-fn aiur_fn_148(
-  inp: [G; IN_148],
+const INPUT_SIZE_145: usize = 4;
+const IN_145: usize = 4;
+const OUT_145: usize = 1;
+fn aiur_fn_145(
+  inp: [G; IN_145],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_148], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_148] = [__v_1];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        let __v_8: G = __loaded[3];
-        let __v_9: G = __loaded[4];
-        let __v_10: G = __loaded[5];
-        let __v_11: G = __loaded[6];
-        let __v_12: G = __loaded[7];
-        let __v_13: G = __loaded[8];
-        let __v_14: G = __loaded[9];
-        let __v_15: G = __loaded[10];
-        let __v_16: G = __loaded[11];
-        let __v_17: G = __loaded[12];
-        let __v_18: G = __loaded[13];
-        let __v_19: G = __loaded[14];
-        let __v_20: G = __loaded[15];
-        let __v_21: G = __loaded[16];
-        let __v_22: G = __loaded[17];
-        let __v_23: G = __loaded[18];
-        let __v_24: G = __loaded[19];
-        let __v_25: G = __loaded[20];
-        let __v_26: G = __loaded[21];
-        let __v_27: G = __loaded[22];
-        let __v_28: G = __loaded[23];
-        let __v_29: G = __loaded[24];
-        let __v_30: G = __loaded[25];
-        let __v_31: G = __loaded[26];
-        let __v_32: G = __loaded[27];
-        let __v_33: G = __loaded[28];
-        let __v_34: G = __loaded[29];
-        let __v_35: G = __loaded[30];
-        let __v_36: G = __loaded[31];
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-        let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_40: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_41: G = __r_arr[0];
-        let __ret: [G; OUT_148] = [__v_41];
-        if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
+    let __v_4: G = G::from_u8(__gb[0]);
+    let __v_5: G = G::from_u8(__gb[1]);
+    let __v_6: G = G::from_u8(__gb[2]);
+    let __v_7: G = G::from_u8(__gb[3]);
+    let __v_8: G = G::from_u8(__gb[4]);
+    let __v_9: G = G::from_u8(__gb[5]);
+    let __v_10: G = G::from_u8(__gb[6]);
+    let __v_11: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_10 + __v_13);
+    let __v_15: G = (__v_9 + __v_14);
+    let __v_16: G = (__v_8 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_6 + __v_7);
+    let __v_19: G = (__v_5 + __v_18);
+    let __v_20: G = (__v_4 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __gb: [u8; 8] = __v_1.as_canonical_u64().to_le_bytes();
+    let __v_22: G = G::from_u8(__gb[0]);
+    let __v_23: G = G::from_u8(__gb[1]);
+    let __v_24: G = G::from_u8(__gb[2]);
+    let __v_25: G = G::from_u8(__gb[3]);
+    let __v_26: G = G::from_u8(__gb[4]);
+    let __v_27: G = G::from_u8(__gb[5]);
+    let __v_28: G = G::from_u8(__gb[6]);
+    let __v_29: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_22; let __vj = __v_23; 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_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); };
+    let __v_30: G = G::from_u64(1020);
+    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 __v_34: G = (__v_26 + __v_33);
+    let __v_35: G = G::from_bool((__v_34 == G::ZERO));
+    let __v_36: G = (__v_24 + __v_25);
+    let __v_37: G = (__v_23 + __v_36);
+    let __v_38: G = (__v_22 + __v_37);
+    let __v_39: G = G::from_bool((__v_38 == G::ZERO));
+    let __gb: [u8; 8] = __v_2.as_canonical_u64().to_le_bytes();
+    let __v_40: G = G::from_u8(__gb[0]);
+    let __v_41: G = G::from_u8(__gb[1]);
+    let __v_42: G = G::from_u8(__gb[2]);
+    let __v_43: G = G::from_u8(__gb[3]);
+    let __v_44: G = G::from_u8(__gb[4]);
+    let __v_45: G = G::from_u8(__gb[5]);
+    let __v_46: G = G::from_u8(__gb[6]);
+    let __v_47: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_44; let __vj = __v_45; 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_46; let __vj = __v_47; 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_48: G = G::from_u64(1020);
+    let __v_49: G = (__v_47 - __v_48);
+    let __v_50: G = (__v_46 + __v_49);
+    let __v_51: G = (__v_45 + __v_50);
+    let __v_52: G = (__v_44 + __v_51);
+    let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+    let __v_54: G = (__v_42 + __v_43);
+    let __v_55: G = (__v_41 + __v_54);
+    let __v_56: G = (__v_40 + __v_55);
+    let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+    let __gb: [u8; 8] = __v_3.as_canonical_u64().to_le_bytes();
+    let __v_58: G = G::from_u8(__gb[0]);
+    let __v_59: G = G::from_u8(__gb[1]);
+    let __v_60: G = G::from_u8(__gb[2]);
+    let __v_61: G = G::from_u8(__gb[3]);
+    let __v_62: G = G::from_u8(__gb[4]);
+    let __v_63: G = G::from_u8(__gb[5]);
+    let __v_64: G = G::from_u8(__gb[6]);
+    let __v_65: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66: G = G::from_u64(1020);
+    let __v_67: G = (__v_65 - __v_66);
+    let __v_68: G = (__v_64 + __v_67);
+    let __v_69: G = (__v_63 + __v_68);
+    let __v_70: G = (__v_62 + __v_69);
+    let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+    let __v_72: G = (__v_60 + __v_61);
+    let __v_73: G = (__v_59 + __v_72);
+    let __v_74: G = (__v_58 + __v_73);
+    let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = G::from_u64(256);
+    let __v_78: G = (__v_77 * __v_5);
+    let __v_79: G = G::from_u64(65536);
+    let __v_80: G = (__v_79 * __v_6);
+    let __v_81: G = G::from_u64(16777216);
+    let __v_82: G = (__v_81 * __v_7);
+    let __v_83: G = G::from_u64(4294967296);
+    let __v_84: G = (__v_83 * __v_8);
+    let __v_85: G = G::from_u64(1099511627776);
+    let __v_86: G = (__v_85 * __v_9);
+    let __v_87: G = G::from_u64(281474976710656);
+    let __v_88: G = (__v_87 * __v_10);
+    let __v_89: G = G::from_u64(72057594037927936);
+    let __v_90: G = (__v_89 * __v_11);
+    let __v_91: G = (__v_88 + __v_90);
+    let __v_92: G = (__v_86 + __v_91);
+    let __v_93: G = (__v_84 + __v_92);
+    let __v_94: G = (__v_82 + __v_93);
+    let __v_95: G = (__v_80 + __v_94);
+    let __v_96: G = (__v_78 + __v_95);
+    let __v_97: G = (__v_4 + __v_96);
+    if (__v_97 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    let __v_98: G = G::from_u64(1);
+    let __v_99: G = G::from_u64(1);
+    let __v_100: G = (__v_99 - __v_21);
+    let __v_101: G = (__v_17 * __v_100);
+    let __v_102: G = (__v_98 - __v_101);
+    let __v_103: G = G::from_u64(1);
+    if (__v_102 != __v_103) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
+    }
+    let __v_104: G = G::from_u64(0);
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_23);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_24);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_25);
+    let __v_111: G = G::from_u64(4294967296);
+    let __v_112: G = (__v_111 * __v_26);
+    let __v_113: G = G::from_u64(1099511627776);
+    let __v_114: G = (__v_113 * __v_27);
+    let __v_115: G = G::from_u64(281474976710656);
+    let __v_116: G = (__v_115 * __v_28);
+    let __v_117: G = G::from_u64(72057594037927936);
+    let __v_118: G = (__v_117 * __v_29);
+    let __v_119: G = (__v_116 + __v_118);
+    let __v_120: G = (__v_114 + __v_119);
+    let __v_121: G = (__v_112 + __v_120);
+    let __v_122: G = (__v_110 + __v_121);
+    let __v_123: G = (__v_108 + __v_122);
+    let __v_124: G = (__v_106 + __v_123);
+    let __v_125: G = (__v_22 + __v_124);
+    if (__v_125 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_125.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    }
+    let __v_126: G = G::from_u64(1);
+    let __v_127: G = G::from_u64(1);
+    let __v_128: G = (__v_127 - __v_39);
+    let __v_129: G = (__v_35 * __v_128);
+    let __v_130: G = (__v_126 - __v_129);
+    let __v_131: G = G::from_u64(1);
+    if (__v_130 != __v_131) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+    }
+    let __v_132: G = G::from_u64(0);
+    let __v_133: G = G::from_u64(256);
+    let __v_134: G = (__v_133 * __v_41);
+    let __v_135: G = G::from_u64(65536);
+    let __v_136: G = (__v_135 * __v_42);
+    let __v_137: G = G::from_u64(16777216);
+    let __v_138: G = (__v_137 * __v_43);
+    let __v_139: G = G::from_u64(4294967296);
+    let __v_140: G = (__v_139 * __v_44);
+    let __v_141: G = G::from_u64(1099511627776);
+    let __v_142: G = (__v_141 * __v_45);
+    let __v_143: G = G::from_u64(281474976710656);
+    let __v_144: G = (__v_143 * __v_46);
+    let __v_145: G = G::from_u64(72057594037927936);
+    let __v_146: G = (__v_145 * __v_47);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_140 + __v_148);
+    let __v_150: G = (__v_138 + __v_149);
+    let __v_151: G = (__v_136 + __v_150);
+    let __v_152: G = (__v_134 + __v_151);
+    let __v_153: G = (__v_40 + __v_152);
+    if (__v_153 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_153.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    }
+    let __v_154: G = G::from_u64(1);
+    let __v_155: G = G::from_u64(1);
+    let __v_156: G = (__v_155 - __v_57);
+    let __v_157: G = (__v_53 * __v_156);
+    let __v_158: G = (__v_154 - __v_157);
+    let __v_159: G = G::from_u64(1);
+    if (__v_158 != __v_159) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_159.as_canonical_u64(), msg: None });
+    }
+    let __v_160: G = G::from_u64(0);
+    let __v_161: G = G::from_u64(256);
+    let __v_162: G = (__v_161 * __v_59);
+    let __v_163: G = G::from_u64(65536);
+    let __v_164: G = (__v_163 * __v_60);
+    let __v_165: G = G::from_u64(16777216);
+    let __v_166: G = (__v_165 * __v_61);
+    let __v_167: G = G::from_u64(4294967296);
+    let __v_168: G = (__v_167 * __v_62);
+    let __v_169: G = G::from_u64(1099511627776);
+    let __v_170: G = (__v_169 * __v_63);
+    let __v_171: G = G::from_u64(281474976710656);
+    let __v_172: G = (__v_171 * __v_64);
+    let __v_173: G = G::from_u64(72057594037927936);
+    let __v_174: G = (__v_173 * __v_65);
+    let __v_175: G = (__v_172 + __v_174);
+    let __v_176: G = (__v_170 + __v_175);
+    let __v_177: G = (__v_168 + __v_176);
+    let __v_178: G = (__v_166 + __v_177);
+    let __v_179: G = (__v_164 + __v_178);
+    let __v_180: G = (__v_162 + __v_179);
+    let __v_181: G = (__v_58 + __v_180);
+    if (__v_181 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_181.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    }
+    let __v_182: G = G::from_u64(1);
+    let __v_183: G = G::from_u64(1);
+    let __v_184: G = (__v_183 - __v_75);
+    let __v_185: G = (__v_71 * __v_184);
+    let __v_186: G = (__v_182 - __v_185);
+    let __v_187: G = G::from_u64(1);
+    if (__v_186 != __v_187) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: None });
     }
+    let __v_188: G = G::from_u64(1);
+    let __v_189: G = G::from_u64(1);
+    let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_145] = [__v_194];
+    if !unconstrained { record.virt += record.function_queries[145].weight(); } record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_149: usize = 2;
-const IN_149: usize = 2;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
+const INPUT_SIZE_146: usize = 6;
+const IN_146: usize = 6;
+const OUT_146: usize = 3;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_149], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    let __v_11: G = __loaded[5];
+    let __v_12: G = __loaded[6];
+    match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_149] = [__v_1];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_146] = [__v_0, __v_1, __v_5];
+        if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __v_6: G = G::from_u64(0);
-        let __v_7: G = G::from_u64(0);
-        let __v_8: G = G::from_u64(0);
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_149] = [__v_13];
-        if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        match __v_7.as_canonical_u64() {
+          _ => {
+            let __v_13: G = (__v_7 - __v_2);
+            let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+            match __v_14.as_canonical_u64() {
+              1u64 => {
+                let __v_15: G = G::from_u64(1);
+                let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_3, __v_4, __v_15]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+                let __v_17: G = __r_arr[1];
+                let __v_18: G = (__v_16 * __v_10);
+                let __v_19: G = G::from_u64(7);
+                let __v_20: G = (__v_17 * __v_11);
+                let __v_21: G = (__v_19 * __v_20);
+                let __v_22: G = (__v_18 + __v_21);
+                let __v_23: G = (__v_16 * __v_11);
+                let __v_24: G = (__v_17 * __v_10);
+                let __v_25: G = (__v_23 + __v_24);
+                let __v_26: G = (__v_0 + __v_22);
+                let __v_27: G = (__v_1 + __v_25);
+                let __ret: [G; OUT_146] = [__v_26, __v_27, __v_12];
+                if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __ret: [G; OUT_146] = [__v_0, __v_1, __v_5];
+                if !unconstrained { record.virt += record.function_queries[146].weight(); } record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+        }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_150: usize = 2;
-const IN_150: usize = 2;
-const OUT_150: usize = 10;
-fn aiur_fn_150(
-  inp: [G; IN_150],
+const INPUT_SIZE_147: usize = 9;
+const IN_147: usize = 9;
+const OUT_147: usize = 3;
+fn aiur_fn_147(
+  inp: [G; IN_147],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_150], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_10: G = __loaded[1];
+    let __v_11: G = __loaded[2];
+    let __v_12: G = __loaded[3];
+    match __v_9.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(103);
-        let __v_6: G = G::from_u64(230);
-        let __v_7: G = G::from_u64(9);
-        let __v_8: G = G::from_u64(106);
-        let __v_9: G = G::from_u64(133);
-        let __v_10: G = G::from_u64(174);
-        let __v_11: G = G::from_u64(103);
-        let __v_12: G = G::from_u64(187);
-        let __v_13: G = G::from_u64(114);
-        let __v_14: G = G::from_u64(243);
-        let __v_15: G = G::from_u64(110);
-        let __v_16: G = G::from_u64(60);
-        let __v_17: G = G::from_u64(58);
-        let __v_18: G = G::from_u64(245);
-        let __v_19: G = G::from_u64(79);
-        let __v_20: G = G::from_u64(165);
-        let __v_21: G = G::from_u64(127);
-        let __v_22: G = G::from_u64(82);
-        let __v_23: G = G::from_u64(14);
-        let __v_24: G = G::from_u64(81);
-        let __v_25: G = G::from_u64(140);
-        let __v_26: G = G::from_u64(104);
-        let __v_27: G = G::from_u64(5);
-        let __v_28: G = G::from_u64(155);
-        let __v_29: G = G::from_u64(171);
-        let __v_30: G = G::from_u64(217);
-        let __v_31: G = G::from_u64(131);
-        let __v_32: G = G::from_u64(31);
-        let __v_33: G = G::from_u64(25);
-        let __v_34: G = G::from_u64(205);
-        let __v_35: G = G::from_u64(224);
-        let __v_36: G = G::from_u64(91);
-        let __v_37: G = G::from_u64(1);
-        let __v_38: G = G::from_u64(1);
-        let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_40: G = G::from_u64(0);
-        let __v_41: G = G::from_u64(0);
-        let __v_42: G = G::from_u64(0);
-        let __v_43: G = G::from_u64(0);
-        let __v_44: G = G::from_u64(0);
-        let __v_45: G = G::from_u64(0);
-        let __v_46: G = G::from_u64(0);
-        let __v_47: G = G::from_u64(0);
-        let __v_48: G = G::from_u64(0);
-        let __v_49: G = G::from_u64(0);
-        let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_52: G = G::from_u64(1);
-        let __v_53: G = G::from_u64(1);
-        let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-        let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-        let __v_56: G = __r_arr[0];
-        let __v_57: G = __r_arr[1];
-        let __v_58: G = __r_arr[2];
-        let __v_59: G = __r_arr[3];
-        let __v_60: G = __r_arr[4];
-        let __v_61: G = __r_arr[5];
-        let __v_62: G = __r_arr[6];
-        let __v_63: G = __r_arr[7];
-        let __v_64: G = __r_arr[8];
-        let __v_65: G = __r_arr[9];
-        let __v_66: G = __r_arr[10];
-        let __v_67: G = __r_arr[11];
-        let __v_68: G = __r_arr[12];
-        let __v_69: G = __r_arr[13];
-        let __v_70: G = __r_arr[14];
-        let __v_71: G = __r_arr[15];
-        let __v_72: G = __r_arr[16];
-        let __v_73: G = __r_arr[17];
-        let __v_74: G = __r_arr[18];
-        let __v_75: G = __r_arr[19];
-        let __v_76: G = __r_arr[20];
-        let __v_77: G = __r_arr[21];
-        let __v_78: G = __r_arr[22];
-        let __v_79: G = __r_arr[23];
-        let __v_80: G = __r_arr[24];
-        let __v_81: G = __r_arr[25];
-        let __v_82: G = __r_arr[26];
-        let __v_83: G = __r_arr[27];
-        let __v_84: G = __r_arr[28];
-        let __v_85: G = __r_arr[29];
-        let __v_86: G = __r_arr[30];
-        let __v_87: G = __r_arr[31];
-        let __v_88: G = G::from_u64(1);
-        let __v_89: G = G::from_u64(1);
-        let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_91: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_92: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_93: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_94: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_95: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_96: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_97: G = __r_arr[0];
-        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_95(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } } else { aiur_fn_95(__args, record, io_buffer, __cu)? } };
-        let __v_98: G = __r_arr[0];
-        let __v_99: G = G::from_u64(1);
-        let __v_100: G = G::from_u64(1);
-        let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_98, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } };
-        let __v_102: 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_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_103: G = __loaded[0];
-        let __v_104: G = __loaded[1];
-        let __v_105: G = __loaded[2];
-        match __v_103.as_canonical_u64() {
+        let __v_13: G = (__v_6 - __v_8);
+        let __v_14: G = G::from_bool((__v_13 == G::ZERO));
+        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: None });
+        }
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__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 { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+        let __v_17: G = G::from_u64(0);
+        if (__v_16 != __v_17) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
+        }
+        let __v_18: G = G::from_u64(1);
+        let __v_19: G = G::from_u64(1);
+        let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_147] = [__v_0, __v_1, __v_20];
+        if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_13: G = __loaded[0];
+        let __v_14: G = __loaded[1];
+        let __v_15: G = __loaded[2];
+        let __v_16: G = __loaded[3];
+        match __v_13.as_canonical_u64() {
           0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_106: G = __loaded[0];
-            let __v_107: G = __loaded[1];
-            let __v_108: G = __loaded[2];
-            match __v_106.as_canonical_u64() {
+            let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_17: G = __loaded[0];
+            let __v_18: G = __loaded[1];
+            let __v_19: G = __loaded[2];
+            match __v_17.as_canonical_u64() {
               0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_109: G = __loaded[0];
-                let __v_110: G = __loaded[1];
-                let __v_111: G = __loaded[2];
-                match __v_109.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_112: G = __loaded[0];
-                    let __v_113: G = __loaded[1];
-                    let __v_114: G = __loaded[2];
-                    match __v_112.as_canonical_u64() {
+                match __v_10.as_canonical_u64() {
+                  _ => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                    let __v_21: G = __loaded[1];
+                    let __v_22: G = __loaded[2];
+                    match __v_20.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_115: G = __loaded[0];
-                        let __v_116: G = __loaded[1];
-                        let __v_117: G = __loaded[2];
-                        match __v_115.as_canonical_u64() {
-                          0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_118: G = __loaded[0];
-                            let __v_119: G = __loaded[1];
-                            let __v_120: G = __loaded[2];
-                            match __v_118.as_canonical_u64() {
-                              0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_121: G = __loaded[0];
-                                let __v_122: G = __loaded[1];
-                                let __v_123: G = __loaded[2];
-                                match __v_121.as_canonical_u64() {
-                                  0u64 => {
-                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                    let __v_124: G = __loaded[0];
-                                    let __v_125: G = __loaded[1];
-                                    let __v_126: G = __loaded[2];
-                                    match __v_124.as_canonical_u64() {
-                                      0u64 => {
-                                        let __ret: [G; OUT_150] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
-                                        if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                        return Ok(__ret);
-                                      },
-                                      _ => {
-                                        return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
-                                      },
-                                    }
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
-                              },
-                            }
-                          },
-                          _ => {
-                            return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
-                          },
+                        let __v_23: G = G::from_u64(1);
+                        let __v_24: G = (__v_6 - __v_23);
+                        let __v_25: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_11, __v_25]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+                        let __v_27: G = __r_arr[1];
+                        let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_0, __v_1, __v_26, __v_27];
+  },
+  _ => {
+    break '__mc_0 [__v_26, __v_27, __v_0, __v_1];
+  },
+}
+ };
+                        let __v_28: G = __mc_out___mc_0[0];
+                        let __v_29: G = __mc_out___mc_0[1];
+                        let __v_30: G = __mc_out___mc_0[2];
+                        let __v_31: G = __mc_out___mc_0[3];
+                        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; 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 { let __r = record.function_queries[120].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+                        let __v_33: G = __r_arr[1];
+                        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; 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 { let __r = record.function_queries[146].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+                        let __v_35: G = __r_arr[1];
+                        let __v_36: G = __r_arr[2];
+                        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; 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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                        let __v_38: G = __r_arr[1];
+                        let __v_39: G = __r_arr[2];
+                        let __gb: [u8; 8] = __v_28.as_canonical_u64().to_le_bytes();
+                        let __v_40: G = G::from_u8(__gb[0]);
+                        let __v_41: G = G::from_u8(__gb[1]);
+                        let __v_42: G = G::from_u8(__gb[2]);
+                        let __v_43: G = G::from_u8(__gb[3]);
+                        let __v_44: G = G::from_u8(__gb[4]);
+                        let __v_45: G = G::from_u8(__gb[5]);
+                        let __v_46: G = G::from_u8(__gb[6]);
+                        let __v_47: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_40; let __vj = __v_41; 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_42; let __vj = __v_43; 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_44; let __vj = __v_45; 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_46; let __vj = __v_47; 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_48: G = G::from_u64(1020);
+                        let __v_49: G = (__v_47 - __v_48);
+                        let __v_50: G = (__v_46 + __v_49);
+                        let __v_51: G = (__v_45 + __v_50);
+                        let __v_52: G = (__v_44 + __v_51);
+                        let __v_53: G = G::from_bool((__v_52 == G::ZERO));
+                        let __v_54: G = (__v_42 + __v_43);
+                        let __v_55: G = (__v_41 + __v_54);
+                        let __v_56: G = (__v_40 + __v_55);
+                        let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+                        let __gb: [u8; 8] = __v_29.as_canonical_u64().to_le_bytes();
+                        let __v_58: G = G::from_u8(__gb[0]);
+                        let __v_59: G = G::from_u8(__gb[1]);
+                        let __v_60: G = G::from_u8(__gb[2]);
+                        let __v_61: G = G::from_u8(__gb[3]);
+                        let __v_62: G = G::from_u8(__gb[4]);
+                        let __v_63: G = G::from_u8(__gb[5]);
+                        let __v_64: G = G::from_u8(__gb[6]);
+                        let __v_65: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_58; let __vj = __v_59; 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_60; let __vj = __v_61; 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_62; let __vj = __v_63; 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_64; let __vj = __v_65; 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_66: G = G::from_u64(1020);
+                        let __v_67: G = (__v_65 - __v_66);
+                        let __v_68: G = (__v_64 + __v_67);
+                        let __v_69: G = (__v_63 + __v_68);
+                        let __v_70: G = (__v_62 + __v_69);
+                        let __v_71: G = G::from_bool((__v_70 == G::ZERO));
+                        let __v_72: G = (__v_60 + __v_61);
+                        let __v_73: G = (__v_59 + __v_72);
+                        let __v_74: G = (__v_58 + __v_73);
+                        let __v_75: G = G::from_bool((__v_74 == G::ZERO));
+                        let __gb: [u8; 8] = __v_30.as_canonical_u64().to_le_bytes();
+                        let __v_76: G = G::from_u8(__gb[0]);
+                        let __v_77: G = G::from_u8(__gb[1]);
+                        let __v_78: G = G::from_u8(__gb[2]);
+                        let __v_79: G = G::from_u8(__gb[3]);
+                        let __v_80: G = G::from_u8(__gb[4]);
+                        let __v_81: G = G::from_u8(__gb[5]);
+                        let __v_82: G = G::from_u8(__gb[6]);
+                        let __v_83: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_76; let __vj = __v_77; 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_78; let __vj = __v_79; 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_80; let __vj = __v_81; 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_82; let __vj = __v_83; 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_84: G = G::from_u64(1020);
+                        let __v_85: G = (__v_83 - __v_84);
+                        let __v_86: G = (__v_82 + __v_85);
+                        let __v_87: G = (__v_81 + __v_86);
+                        let __v_88: G = (__v_80 + __v_87);
+                        let __v_89: G = G::from_bool((__v_88 == G::ZERO));
+                        let __v_90: G = (__v_78 + __v_79);
+                        let __v_91: G = (__v_77 + __v_90);
+                        let __v_92: G = (__v_76 + __v_91);
+                        let __v_93: G = G::from_bool((__v_92 == G::ZERO));
+                        let __gb: [u8; 8] = __v_31.as_canonical_u64().to_le_bytes();
+                        let __v_94: G = G::from_u8(__gb[0]);
+                        let __v_95: G = G::from_u8(__gb[1]);
+                        let __v_96: G = G::from_u8(__gb[2]);
+                        let __v_97: G = G::from_u8(__gb[3]);
+                        let __v_98: G = G::from_u8(__gb[4]);
+                        let __v_99: G = G::from_u8(__gb[5]);
+                        let __v_100: G = G::from_u8(__gb[6]);
+                        let __v_101: G = G::from_u8(__gb[7]);
+                        if !unconstrained { let __vi = __v_94; let __vj = __v_95; 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_96; let __vj = __v_97; 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_98; let __vj = __v_99; 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_100; let __vj = __v_101; 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_102: G = G::from_u64(1020);
+                        let __v_103: G = (__v_101 - __v_102);
+                        let __v_104: G = (__v_100 + __v_103);
+                        let __v_105: G = (__v_99 + __v_104);
+                        let __v_106: G = (__v_98 + __v_105);
+                        let __v_107: G = G::from_bool((__v_106 == G::ZERO));
+                        let __v_108: G = (__v_96 + __v_97);
+                        let __v_109: G = (__v_95 + __v_108);
+                        let __v_110: G = (__v_94 + __v_109);
+                        let __v_111: G = G::from_bool((__v_110 == G::ZERO));
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+                        let __v_113: G = G::from_u64(1);
+                        if (__v_112 != __v_113) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_112.as_canonical_u64(), rhs: __v_113.as_canonical_u64(), msg: None });
                         }
-                      },
-                      _ => {
-                        return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
-                      },
-                    }
-                  },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                        let __v_114: G = G::from_u64(0);
+                        let __v_115: G = G::from_u64(0);
+                        let __v_116: G = G::from_u64(256);
+                        let __v_117: G = (__v_116 * __v_41);
+                        let __v_118: G = G::from_u64(65536);
+                        let __v_119: G = (__v_118 * __v_42);
+                        let __v_120: G = G::from_u64(16777216);
+                        let __v_121: G = (__v_120 * __v_43);
+                        let __v_122: G = G::from_u64(4294967296);
+                        let __v_123: G = (__v_122 * __v_44);
+                        let __v_124: G = G::from_u64(1099511627776);
+                        let __v_125: G = (__v_124 * __v_45);
+                        let __v_126: G = G::from_u64(281474976710656);
+                        let __v_127: G = (__v_126 * __v_46);
+                        let __v_128: G = G::from_u64(72057594037927936);
+                        let __v_129: G = (__v_128 * __v_47);
+                        let __v_130: G = (__v_127 + __v_129);
+                        let __v_131: G = (__v_125 + __v_130);
+                        let __v_132: G = (__v_123 + __v_131);
+                        let __v_133: G = (__v_121 + __v_132);
+                        let __v_134: G = (__v_119 + __v_133);
+                        let __v_135: G = (__v_117 + __v_134);
+                        let __v_136: G = (__v_40 + __v_135);
+                        if (__v_136 != __v_28) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
+                        }
+                        let __v_137: G = G::from_u64(1);
+                        let __v_138: G = G::from_u64(1);
+                        let __v_139: G = (__v_138 - __v_57);
+                        let __v_140: G = (__v_53 * __v_139);
+                        let __v_141: G = (__v_137 - __v_140);
+                        let __v_142: G = G::from_u64(1);
+                        if (__v_141 != __v_142) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_142.as_canonical_u64(), msg: None });
+                        }
+                        let __v_143: G = G::from_u64(0);
+                        let __v_144: G = G::from_u64(256);
+                        let __v_145: G = (__v_144 * __v_59);
+                        let __v_146: G = G::from_u64(65536);
+                        let __v_147: G = (__v_146 * __v_60);
+                        let __v_148: G = G::from_u64(16777216);
+                        let __v_149: G = (__v_148 * __v_61);
+                        let __v_150: G = G::from_u64(4294967296);
+                        let __v_151: G = (__v_150 * __v_62);
+                        let __v_152: G = G::from_u64(1099511627776);
+                        let __v_153: G = (__v_152 * __v_63);
+                        let __v_154: G = G::from_u64(281474976710656);
+                        let __v_155: G = (__v_154 * __v_64);
+                        let __v_156: G = G::from_u64(72057594037927936);
+                        let __v_157: G = (__v_156 * __v_65);
+                        let __v_158: G = (__v_155 + __v_157);
+                        let __v_159: G = (__v_153 + __v_158);
+                        let __v_160: G = (__v_151 + __v_159);
+                        let __v_161: G = (__v_149 + __v_160);
+                        let __v_162: G = (__v_147 + __v_161);
+                        let __v_163: G = (__v_145 + __v_162);
+                        let __v_164: G = (__v_58 + __v_163);
+                        if (__v_164 != __v_29) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_164.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                        }
+                        let __v_165: G = G::from_u64(1);
+                        let __v_166: G = G::from_u64(1);
+                        let __v_167: G = (__v_166 - __v_75);
+                        let __v_168: G = (__v_71 * __v_167);
+                        let __v_169: G = (__v_165 - __v_168);
+                        let __v_170: G = G::from_u64(1);
+                        if (__v_169 != __v_170) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_170.as_canonical_u64(), msg: None });
+                        }
+                        let __v_171: G = G::from_u64(0);
+                        let __v_172: G = G::from_u64(256);
+                        let __v_173: G = (__v_172 * __v_77);
+                        let __v_174: G = G::from_u64(65536);
+                        let __v_175: G = (__v_174 * __v_78);
+                        let __v_176: G = G::from_u64(16777216);
+                        let __v_177: G = (__v_176 * __v_79);
+                        let __v_178: G = G::from_u64(4294967296);
+                        let __v_179: G = (__v_178 * __v_80);
+                        let __v_180: G = G::from_u64(1099511627776);
+                        let __v_181: G = (__v_180 * __v_81);
+                        let __v_182: G = G::from_u64(281474976710656);
+                        let __v_183: G = (__v_182 * __v_82);
+                        let __v_184: G = G::from_u64(72057594037927936);
+                        let __v_185: G = (__v_184 * __v_83);
+                        let __v_186: G = (__v_183 + __v_185);
+                        let __v_187: G = (__v_181 + __v_186);
+                        let __v_188: G = (__v_179 + __v_187);
+                        let __v_189: G = (__v_177 + __v_188);
+                        let __v_190: G = (__v_175 + __v_189);
+                        let __v_191: G = (__v_173 + __v_190);
+                        let __v_192: G = (__v_76 + __v_191);
+                        if (__v_192 != __v_30) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+                        }
+                        let __v_193: G = G::from_u64(1);
+                        let __v_194: G = G::from_u64(1);
+                        let __v_195: G = (__v_194 - __v_93);
+                        let __v_196: G = (__v_89 * __v_195);
+                        let __v_197: G = (__v_193 - __v_196);
+                        let __v_198: G = G::from_u64(1);
+                        if (__v_197 != __v_198) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_198.as_canonical_u64(), msg: None });
+                        }
+                        let __v_199: G = G::from_u64(0);
+                        let __v_200: G = G::from_u64(256);
+                        let __v_201: G = (__v_200 * __v_95);
+                        let __v_202: G = G::from_u64(65536);
+                        let __v_203: G = (__v_202 * __v_96);
+                        let __v_204: G = G::from_u64(16777216);
+                        let __v_205: G = (__v_204 * __v_97);
+                        let __v_206: G = G::from_u64(4294967296);
+                        let __v_207: G = (__v_206 * __v_98);
+                        let __v_208: G = G::from_u64(1099511627776);
+                        let __v_209: G = (__v_208 * __v_99);
+                        let __v_210: G = G::from_u64(281474976710656);
+                        let __v_211: G = (__v_210 * __v_100);
+                        let __v_212: G = G::from_u64(72057594037927936);
+                        let __v_213: G = (__v_212 * __v_101);
+                        let __v_214: G = (__v_211 + __v_213);
+                        let __v_215: G = (__v_209 + __v_214);
+                        let __v_216: G = (__v_207 + __v_215);
+                        let __v_217: G = (__v_205 + __v_216);
+                        let __v_218: G = (__v_203 + __v_217);
+                        let __v_219: G = (__v_201 + __v_218);
+                        let __v_220: G = (__v_94 + __v_219);
+                        if (__v_220 != __v_31) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_220.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+                        }
+                        let __v_221: G = G::from_u64(1);
+                        let __v_222: G = G::from_u64(1);
+                        let __v_223: G = (__v_222 - __v_111);
+                        let __v_224: G = (__v_107 * __v_223);
+                        let __v_225: G = (__v_221 - __v_224);
+                        let __v_226: G = G::from_u64(1);
+                        if (__v_225 != __v_226) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_225.as_canonical_u64(), rhs: __v_226.as_canonical_u64(), msg: None });
+                        }
+                        let __v_227: G = G::from_u64(1);
+                        let __v_228: G = G::from_u64(1);
+                        let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __ret: [G; OUT_147] = [__v_37, __v_38, __v_234];
+                        if !unconstrained { record.virt += record.function_queries[147].weight(); } record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                      },
+                    }
                   },
                 }
               },
               _ => {
-                return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+                return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
               },
             }
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
           },
         }
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_5: G = __loaded[0];
-        let __v_6: G = __loaded[1];
-        let __v_7: G = __loaded[2];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-            let __v_8: G = __loaded[0];
-            let __v_9: G = __loaded[1];
-            let __v_10: G = __loaded[2];
-            match __v_8.as_canonical_u64() {
-              0u64 => {
-                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                let __v_11: G = __loaded[0];
-                let __v_12: G = __loaded[1];
-                let __v_13: G = __loaded[2];
-                match __v_11.as_canonical_u64() {
-                  0u64 => {
-                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                    let __v_14: G = __loaded[0];
-                    let __v_15: G = __loaded[1];
-                    let __v_16: G = __loaded[2];
-                    match __v_14.as_canonical_u64() {
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_148: usize = 25;
+const IN_148: usize = 25;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    match __v_1.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_15, __v_19, __v_18, __v_20]; 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 { let __r = record.function_queries[131].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+        let __v_26: G = G::from_u64(0);
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_19, __v_18, __v_26]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        let __v_28: G = G::from_u64(0);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_28]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        match __v_29.as_canonical_u64() {
+          _ => {
+            let __v_30: G = G::from_u64(0);
+            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+            let __v_32: G = G::from_u64(1);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_32]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+            match __v_33.as_canonical_u64() {
+              _ => {
+                let __v_34: G = G::from_u64(0);
+                let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; 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 { let __r = record.function_queries[137].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+                let __v_36: G = G::from_u64(2);
+                let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_36]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                match __v_37.as_canonical_u64() {
+                  _ => {
+                    let __v_38: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __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 { let __r = record.function_queries[138].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+                    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; 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 { let __r = record.function_queries[140].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+                    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_40, __v_19]; 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 { let __r = record.function_queries[133].replay_at(__i); record.virt += __r; } 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 __v_41: G = __r_arr[0];
+                    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
+                    let __v_42: G = __loaded[0];
+                    let __v_43: G = __loaded[1];
+                    let __v_44: G = __loaded[2];
+                    let __v_45: G = __loaded[3];
+                    let __v_46: G = __loaded[4];
+                    let __v_47: G = __loaded[5];
+                    let __v_48: G = __loaded[6];
+                    match __v_42.as_canonical_u64() {
                       0u64 => {
-                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                        let __v_17: G = __loaded[0];
-                        let __v_18: G = __loaded[1];
-                        let __v_19: G = __loaded[2];
-                        match __v_17.as_canonical_u64() {
-                          0u64 => {
-                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                            let __v_20: G = __loaded[0];
-                            let __v_21: G = __loaded[1];
-                            let __v_22: G = __loaded[2];
-                            match __v_20.as_canonical_u64() {
-                              0u64 => {
-                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-                                let __v_23: G = __loaded[0];
-                                let __v_24: G = __loaded[1];
-                                let __v_25: G = __loaded[2];
-                                match __v_23.as_canonical_u64() {
-                                  0u64 => {
-                                    let __ret: [G; OUT_150] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
-                                    if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                                    return Ok(__ret);
-                                  },
-                                  _ => {
-                                    return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
-                                  },
-                                }
-                              },
-                              _ => {
-                                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
-                              },
-                            }
-                          },
+                        match __v_43.as_canonical_u64() {
                           _ => {
-                            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                            let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; 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 { let __r = record.function_queries[147].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+                            let __v_50: G = __r_arr[1];
+                            let __v_51: G = __r_arr[2];
+                            let __v_52: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_23, __v_52]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_53: G = __r_arr[0];
+                            let __v_54: G = __r_arr[1];
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+                            let __v_56: G = (__v_55 - __v_24);
+                            let __v_57: G = G::from_bool((__v_56 == G::ZERO));
+                            let __v_58: G = G::from_u64(1);
+                            if (__v_57 != __v_58) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+                            }
+                            let __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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+                            let __v_60: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_9]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+                            let __v_62: G = (__v_60 + __v_61);
+                            let __v_63: G = (__v_59 - __v_62);
+                            let __v_64: G = G::from_bool((__v_63 == G::ZERO));
+                            let __v_65: G = G::from_u64(1);
+                            if (__v_64 != __v_65) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_29]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_66: G = __r_arr[0];
+                            let __v_67: G = (__v_66 - __v_18);
+                            let __v_68: G = G::from_bool((__v_67 == G::ZERO));
+                            let __v_69: G = G::from_u64(1);
+                            if (__v_68 != __v_69) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_33]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_70: G = __r_arr[0];
+                            let __v_71: G = (__v_70 - __v_18);
+                            let __v_72: G = G::from_bool((__v_71 == G::ZERO));
+                            let __v_73: G = G::from_u64(1);
+                            if (__v_72 != __v_73) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_74: G = __r_arr[0];
+                            let __v_75: G = (__v_74 - __v_18);
+                            let __v_76: G = G::from_bool((__v_75 == G::ZERO));
+                            let __v_77: G = G::from_u64(1);
+                            if (__v_76 != __v_77) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+                            }
+                            let __v_78: G = (__v_43 - __v_20);
+                            let __v_79: G = G::from_bool((__v_78 == G::ZERO));
+                            let __v_80: G = G::from_u64(1);
+                            if (__v_79 != __v_80) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_80.as_canonical_u64(), msg: None });
+                            }
+                            let __v_81: G = (__v_53 - __v_49);
+                            let __v_82: G = G::from_bool((__v_81 == G::ZERO));
+                            let __v_83: G = (__v_54 - __v_50);
+                            let __v_84: G = G::from_bool((__v_83 == G::ZERO));
+                            let __v_85: G = (__v_82 * __v_84);
+                            let __v_86: G = G::from_u64(1);
+                            if (__v_85 != __v_86) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None });
+                            }
+                            let __ret: [G; OUT_148] = [__v_51];
+                            if !unconstrained { record.virt += record.function_queries[148].weight(); } record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
                           },
                         }
                       },
                       _ => {
-                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                        return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
                       },
                     }
                   },
-                  _ => {
-                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
-                  },
                 }
               },
-              _ => {
-                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
-              },
             }
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
         }
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
     }
   })
 }
 
-const INPUT_SIZE_151: usize = 2;
-const IN_151: usize = 2;
-const OUT_151: usize = 10;
-fn aiur_fn_151(
-  inp: [G; IN_151],
+const INPUT_SIZE_149: usize = 25;
+const IN_149: usize = 25;
+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_151], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __v_4: G = __r_arr[2];
-    let __v_5: G = __r_arr[3];
-    let __v_6: G = __r_arr[4];
-    let __v_7: G = __r_arr[5];
-    let __v_8: G = __r_arr[6];
-    let __v_9: G = __r_arr[7];
-    let __v_10: G = __r_arr[8];
-    let __v_11: G = __r_arr[9];
-    let __v_12: G = G::from_u64(1020);
-    let __v_13: G = (__v_9 - __v_12);
-    let __v_14: G = (__v_8 + __v_13);
-    let __v_15: G = (__v_7 + __v_14);
-    let __v_16: G = (__v_6 + __v_15);
-    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
-    let __v_18: G = (__v_4 + __v_5);
-    let __v_19: G = (__v_3 + __v_18);
-    let __v_20: G = (__v_2 + __v_19);
-    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = G::from_u64(1);
-    let __v_24: G = (__v_23 - __v_21);
-    let __v_25: G = (__v_17 * __v_24);
-    let __v_26: G = (__v_22 - __v_25);
-    match __v_26.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_26: G = __loaded[1];
+    let __v_27: G = __loaded[2];
+    let __v_28: G = __loaded[3];
+    match __v_25.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_151] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_149] = [__v_31];
+        if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        let __v_28: G = __r_arr[1];
-        let __v_29: G = __r_arr[2];
-        let __v_30: G = __r_arr[3];
-        let __v_31: G = __r_arr[4];
-        let __v_32: G = __r_arr[5];
-        let __v_33: G = __r_arr[6];
-        let __v_34: G = __r_arr[7];
-        let __v_35: G = __r_arr[8];
-        let __v_36: G = __r_arr[9];
-        let __ret: [G; OUT_151] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-        if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      0u64 => {
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_1, __v_20]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        let __v_30: G = __r_arr[1];
+        let __v_31: G = __r_arr[2];
+        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; 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 { let __r = record.function_queries[148].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+        let __v_33: G = G::from_u64(0);
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_149] = [__v_35];
+        if !unconstrained { record.virt += record.function_queries[149].weight(); } record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_152: usize = 2;
-const IN_152: usize = 2;
-const OUT_152: usize = 18;
-fn aiur_fn_152(
-  inp: [G; IN_152],
+const INPUT_SIZE_150: usize = 4;
+const IN_150: usize = 4;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_152], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __v_3: G = __r_arr[1];
-    let __v_4: G = __r_arr[2];
-    let __v_5: G = __r_arr[3];
-    let __v_6: G = __r_arr[4];
-    let __v_7: G = __r_arr[5];
-    let __v_8: G = __r_arr[6];
-    let __v_9: G = __r_arr[7];
-    let __v_10: G = __r_arr[8];
-    let __v_11: G = __r_arr[9];
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __v_13: G = __r_arr[1];
-    let __v_14: G = __r_arr[2];
-    let __v_15: G = __r_arr[3];
-    let __v_16: G = __r_arr[4];
-    let __v_17: G = __r_arr[5];
-    let __v_18: G = __r_arr[6];
-    let __v_19: G = __r_arr[7];
-    let __v_20: G = __r_arr[8];
-    let __v_21: G = __r_arr[9];
-    let __ret: [G; OUT_152] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-    if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_150] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_1, __v_3]; 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 { let __r = record.function_queries[169].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = __r_arr[2];
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = (__v_2 - __v_8);
+        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_5, __v_6, __v_9, __v_3]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_150] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[150].weight(); } record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_153: usize = 2;
-const IN_153: usize = 2;
-const OUT_153: usize = 1;
-fn aiur_fn_153(
-  inp: [G; IN_153],
+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_153], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_153] = [__v_4];
-        if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_151] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      _ => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_2: G = __loaded[0];
-        let __v_3: G = __loaded[1];
-        let __v_4: G = __loaded[2];
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_5: G = G::from_u64(0);
-            let __v_6: G = G::from_u64(1);
-            let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_1]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_1]; 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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
-            let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_153] = [__v_9];
-            if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_151] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[151].weight(); } record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
         }
       },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
     }
   })
 }
 
-const INPUT_SIZE_154: usize = 3;
-const IN_154: usize = 3;
-const OUT_154: usize = 3;
-fn aiur_fn_154(
-  inp: [G; IN_154],
+const INPUT_SIZE_152: usize = 2;
+const IN_152: usize = 2;
+const OUT_152: usize = 1;
+fn aiur_fn_152(
+  inp: [G; IN_152],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_154], ExecError> {
+) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = __r_arr[2];
-    let __v_6: G = __r_arr[3];
-    let __v_7: G = __r_arr[4];
-    let __v_8: G = __r_arr[5];
-    let __v_9: G = __r_arr[6];
-    let __v_10: G = __r_arr[7];
-    let __v_11: G = __r_arr[8];
-    let __v_12: G = __r_arr[9];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) };
-    let __v_13: G = __b1_out[0];
-    let __v_14: G = __b1_out[1];
-    let __v_15: G = __b1_out[2];
-    let __v_16: G = __b1_out[3];
-    let __v_17: G = __b1_out[4];
-    let __v_18: G = __b1_out[5];
-    let __v_19: G = __b1_out[6];
-    let __v_20: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) };
-    let __v_21: G = __b1_out[0];
-    let __v_22: G = __b1_out[1];
-    let __v_23: G = __b1_out[2];
-    let __v_24: G = __b1_out[3];
-    let __v_25: G = __b1_out[4];
-    let __v_26: G = __b1_out[5];
-    let __v_27: G = __b1_out[6];
-    let __v_28: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
-    let __v_29: G = __b1_out[0];
-    let __v_30: G = __b1_out[1];
-    let __v_31: G = __b1_out[2];
-    let __v_32: G = __b1_out[3];
-    let __v_33: G = __b1_out[4];
-    let __v_34: G = __b1_out[5];
-    let __v_35: G = __b1_out[6];
-    let __v_36: G = __b1_out[7];
-    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
-    let __v_37: G = __b1_out[0];
-    let __v_38: G = __b1_out[1];
-    let __v_39: G = __b1_out[2];
-    let __v_40: G = __b1_out[3];
-    let __v_41: G = __b1_out[4];
-    let __v_42: G = __b1_out[5];
-    let __v_43: G = __b1_out[6];
-    let __v_44: G = __b1_out[7];
-    let __v_45: G = G::from_u64(1);
-    let __v_46: G = G::from_u64(1);
-    let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_49: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_50: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_51: G = __r_arr[0];
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_51, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } };
-    let __v_52: G = __r_arr[0];
-    let __ret: [G; OUT_154] = [__v_52, __v_11, __v_12];
-    if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_152] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_3.as_canonical_u64() {
+          _ => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_1]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_1]; 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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_152] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[152].weight(); } record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_155: usize = 9;
-const IN_155: usize = 9;
-const OUT_155: usize = 1;
-fn aiur_fn_155(
-  inp: [G; IN_155],
+const INPUT_SIZE_153: usize = 4;
+const IN_153: usize = 4;
+const OUT_153: usize = 1;
+fn aiur_fn_153(
+  inp: [G; IN_153],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_155], ExecError> {
+) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = G::from_u64(1);
-    let __v_10: G = G::from_u64(1);
-    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_155] = [__v_13];
-    if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    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; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_153] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_0, __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 { let __r = record.function_queries[151].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_2]; 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 { let __r = record.function_queries[152].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_2 + __v_7);
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_3 - __v_9);
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_8, __v_10]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_153] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[153].weight(); } record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_156: usize = 2;
-const IN_156: usize = 2;
-const OUT_156: usize = 1;
-fn aiur_fn_156(
-  inp: [G; IN_156],
+const INPUT_SIZE_154: usize = 13;
+const IN_154: usize = 13;
+const OUT_154: usize = 1;
+fn aiur_fn_154(
+  inp: [G; IN_154],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_156], ExecError> {
+) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = G::from_u64(1);
-    let __v_3: G = G::from_u64(1);
-    let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-    let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_156] = [__v_6];
-    if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = G::from_u64(0);
+    let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_9, __v_11, __v_10, __v_13]; 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 { let __r = record.function_queries[141].replay_at(__i); record.virt += __r; } 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 __v_15: G = G::from_u64(0);
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    match __v_16.as_canonical_u64() {
+      _ => {
+        let __v_18: G = G::from_u64(1);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        match __v_19.as_canonical_u64() {
+          _ => {
+            let __v_21: G = G::from_u64(2);
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_21]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+            let __v_23: G = __r_arr[1];
+            match __v_22.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+                let __v_25: G = G::from_u64(1);
+                if (__v_24 != __v_25) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_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: None });
+                }
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+                let __v_29: G = G::from_u64(1);
+                if (__v_28 != __v_29) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+                }
+                match __v_6.as_canonical_u64() {
+                  0u64 => {
+                    let __v_30: G = G::from_u64(1);
+                    let __ret: [G; OUT_154] = [__v_30];
+                    if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __v_30: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_30]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                    let __v_32: G = __r_arr[1];
+                    match __v_31.as_canonical_u64() {
+                      _ => {
+                        let __v_33: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_11, __v_8, __v_10, __v_33]; 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 { let __r = record.function_queries[143].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_34]; 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 { let __r = record.function_queries[142].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+                        let __v_36: G = (__v_12 - __v_35);
+                        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_1, __v_36]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+                        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+                        let __ret: [G; OUT_154] = [__v_38];
+                        if !unconstrained { record.virt += record.function_queries[154].weight(); } record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
   })
 }
 
-const INPUT_SIZE_157: usize = 1;
-const IN_157: usize = 1;
-const OUT_157: usize = 1;
-fn aiur_fn_157(
-  inp: [G; IN_157],
+const INPUT_SIZE_155: usize = 2;
+const IN_155: usize = 2;
+const OUT_155: usize = 1;
+fn aiur_fn_155(
+  inp: [G; IN_155],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_157], ExecError> {
+) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __v_1: G = G::from_u64(0);
-    let __v_2: G = G::from_u64(109);
-    let __v_3: G = G::from_u64(0);
-    let __v_4: G = G::from_u64(117);
-    let __v_5: G = G::from_u64(0);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(0);
-    let __v_8: G = G::from_u64(116);
-    let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(105);
-    let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(45);
-    let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(115);
-    let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(116);
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(97);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(114);
-    let __v_21: G = G::from_u64(0);
-    let __v_22: G = G::from_u64(107);
-    let __v_23: G = G::from_u64(0);
-    let __v_24: G = G::from_u64(47);
-    let __v_25: G = G::from_u64(0);
-    let __v_26: G = G::from_u64(118);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(48);
-    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_157] = [__v_42];
-    if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_155] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_3, __v_1]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+        let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_4, __v_1]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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];
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_155] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[155].weight(); } record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_158: usize = 2;
-const IN_158: usize = 2;
-const OUT_158: usize = 1;
-fn aiur_fn_158(
-  inp: [G; IN_158],
+const INPUT_SIZE_156: usize = 2;
+const IN_156: usize = 2;
+const OUT_156: usize = 1;
+fn aiur_fn_156(
+  inp: [G; IN_156],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_158], ExecError> {
+) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    let __v_10: G = __loaded[8];
-    let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_158] = [__v_1];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_156] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_3, __v_1]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; 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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_158] = [__v_13];
-        if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_13: G = { let __values: [G; 3] = [__v_5, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_156] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[156].weight(); } record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -14707,49 +15021,109 @@ fn aiur_fn_158(
   })
 }
 
-const INPUT_SIZE_159: usize = 2;
-const IN_159: usize = 2;
-const OUT_159: usize = 1;
-fn aiur_fn_159(
-  inp: [G; IN_159],
+const INPUT_SIZE_157: usize = 6;
+const IN_157: usize = 6;
+const OUT_157: usize = 1;
+fn aiur_fn_157(
+  inp: [G; IN_157],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_159], ExecError> {
+) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_159] = [__v_4];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    let __v_9: G = __loaded[3];
+    let __v_10: G = __loaded[4];
+    match __v_6.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_159] = [__v_1];
-        if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+        let __v_12: G = G::from_bool((__v_11 == G::ZERO));
+        let __ret: [G; OUT_157] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_11: G = __loaded[0];
+        let __v_12: G = __loaded[1];
+        let __v_13: G = __loaded[2];
+        match __v_11.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              _ => {
+                let __v_14: G = G::from_u64(1);
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_3, __v_14]; 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 { let __r = record.function_queries[155].replay_at(__i); record.virt += __r; } 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_15: G = __r_arr[0];
+                let __v_16: G = G::from_u64(1);
+                let __v_17: G = (__v_5 - __v_16);
+                let __v_18: G = G::from_u64(1);
+                if (__v_7 != __v_18) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None });
+                }
+                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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+                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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+                if (__v_19 != __v_20) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None });
+                }
+                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_2, __v_4]; 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 { let __r = record.function_queries[156].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+                let __v_22: G = G::from_u64(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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; 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 { let __r = record.function_queries[117].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+                let __v_28: G = G::from_u64(1);
+                if (__v_27 != __v_28) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: None });
+                }
+                let __v_29: G = G::from_u64(1);
+                let __v_30: G = (__v_4 + __v_29);
+                let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+                let __ret: [G; OUT_157] = [__v_31];
+                if !unconstrained { record.virt += record.function_queries[157].weight(); } record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+          },
+        }
+      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_160: usize = 9;
-const IN_160: usize = 9;
-const OUT_160: usize = 9;
-fn aiur_fn_160(
-  inp: [G; IN_160],
+const INPUT_SIZE_158: usize = 32;
+const IN_158: usize = 32;
+const OUT_158: usize = 1;
+fn aiur_fn_158(
+  inp: [G; IN_158],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_160], ExecError> {
+) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -14759,634 +15133,330 @@ fn aiur_fn_160(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-    let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-    let __v_13: G = __r_arr[0];
-    let __v_14: G = G::from_u64(0);
-    let __v_15: G = G::from_u64(109);
-    let __v_16: G = G::from_u64(0);
-    let __v_17: G = G::from_u64(117);
-    let __v_18: G = G::from_u64(0);
-    let __v_19: G = G::from_u64(108);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(116);
-    let __v_22: G = G::from_u64(0);
-    let __v_23: G = G::from_u64(105);
-    let __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(45);
-    let __v_26: G = G::from_u64(0);
-    let __v_27: G = G::from_u64(115);
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(116);
-    let __v_30: G = G::from_u64(0);
-    let __v_31: G = G::from_u64(97);
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(114);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = G::from_u64(107);
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = G::from_u64(47);
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = G::from_u64(118);
-    let __v_40: G = G::from_u64(0);
-    let __v_41: G = G::from_u64(48);
-    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_56: G = G::from_u64(1);
-    let __v_57: G = G::from_u64(1);
-    let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_59: G = __r_arr[0];
-    let __v_60: G = __r_arr[1];
-    let __v_61: G = __r_arr[2];
-    let __v_62: G = __r_arr[3];
-    let __v_63: G = __r_arr[4];
-    let __v_64: G = __r_arr[5];
-    let __v_65: G = __r_arr[6];
-    let __v_66: G = __r_arr[7];
-    let __v_67: G = __r_arr[8];
-    let __v_68: G = __r_arr[9];
-    let __v_69: G = __r_arr[10];
-    let __v_70: G = __r_arr[11];
-    let __v_71: G = __r_arr[12];
-    let __v_72: G = __r_arr[13];
-    let __v_73: G = __r_arr[14];
-    let __v_74: G = __r_arr[15];
-    let __v_75: G = __r_arr[16];
-    let __v_76: G = __r_arr[17];
-    let __v_77: G = G::from_u64(1);
-    let __v_78: G = G::from_u64(1);
-    let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_80: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_81: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_75, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_82: G = __r_arr[0];
-    let __v_83: G = G::from_u64(1);
-    let __v_84: G = G::from_u64(1);
-    let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_82, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_86: G = __r_arr[0];
-    let __v_87: G = __r_arr[1];
-    let __v_88: G = __r_arr[2];
-    let __v_89: G = __r_arr[3];
-    let __v_90: G = __r_arr[4];
-    let __v_91: G = __r_arr[5];
-    let __v_92: G = __r_arr[6];
-    let __v_93: G = __r_arr[7];
-    let __v_94: G = __r_arr[8];
-    let __v_95: G = __r_arr[9];
-    let __v_96: G = __r_arr[10];
-    let __v_97: G = __r_arr[11];
-    let __v_98: G = __r_arr[12];
-    let __v_99: G = __r_arr[13];
-    let __v_100: G = __r_arr[14];
-    let __v_101: G = __r_arr[15];
-    let __v_102: G = __r_arr[16];
-    let __v_103: G = __r_arr[17];
-    let __v_104: G = G::from_u64(1);
-    let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_107: G = __r_arr[0];
-    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-    let __v_108: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_102, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_109: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_109, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-    let __v_110: G = __r_arr[0];
-    let __v_111: G = G::from_u64(1);
-    let __v_112: G = G::from_u64(1);
-    let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_8, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-    let __v_114: G = __r_arr[0];
-    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_110, __v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-    let __v_115: G = __r_arr[0];
-    let __v_116: G = G::from_u64(1);
-    let __v_117: G = G::from_u64(1);
-    let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_115, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_119: G = __r_arr[0];
-    let __v_120: G = __r_arr[1];
-    let __v_121: G = __r_arr[2];
-    let __v_122: G = __r_arr[3];
-    let __v_123: G = __r_arr[4];
-    let __v_124: G = __r_arr[5];
-    let __v_125: G = __r_arr[6];
-    let __v_126: G = __r_arr[7];
-    let __v_127: G = __r_arr[8];
-    let __v_128: G = __r_arr[9];
-    let __v_129: G = __r_arr[10];
-    let __v_130: G = __r_arr[11];
-    let __v_131: G = __r_arr[12];
-    let __v_132: G = __r_arr[13];
-    let __v_133: G = __r_arr[14];
-    let __v_134: G = __r_arr[15];
-    let __v_135: G = __r_arr[16];
-    let __v_136: G = __r_arr[17];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_135, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-    let __v_137: G = __r_arr[0];
-    let __v_138: G = G::from_u64(1);
-    let __v_139: G = G::from_u64(1);
-    let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_137, __v_140]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-    let __v_141: G = __r_arr[0];
-    let __v_142: G = __r_arr[1];
-    let __v_143: G = __r_arr[2];
-    let __v_144: G = __r_arr[3];
-    let __v_145: G = __r_arr[4];
-    let __v_146: G = __r_arr[5];
-    let __v_147: G = __r_arr[6];
-    let __v_148: G = __r_arr[7];
-    let __v_149: G = __r_arr[8];
-    let __v_150: G = __r_arr[9];
-    let __v_151: G = __r_arr[10];
-    let __v_152: G = __r_arr[11];
-    let __v_153: G = __r_arr[12];
-    let __v_154: G = __r_arr[13];
-    let __v_155: G = __r_arr[14];
-    let __v_156: G = __r_arr[15];
-    let __v_157: G = __r_arr[16];
-    let __v_158: G = __r_arr[17];
-    let __v_159: G = G::from_u64(256);
-    let __v_160: G = (__v_159 * __v_60);
-    let __v_161: G = G::from_u64(65536);
-    let __v_162: G = (__v_161 * __v_61);
-    let __v_163: G = G::from_u64(16777216);
-    let __v_164: G = (__v_163 * __v_62);
-    let __v_165: G = G::from_u64(4294967296);
-    let __v_166: G = (__v_165 * __v_63);
-    let __v_167: G = G::from_u64(1099511627776);
-    let __v_168: G = (__v_167 * __v_64);
-    let __v_169: G = G::from_u64(281474976710656);
-    let __v_170: G = (__v_169 * __v_65);
-    let __v_171: G = G::from_u64(72057594037927936);
-    let __v_172: G = (__v_171 * __v_66);
-    let __v_173: G = (__v_170 + __v_172);
-    let __v_174: G = (__v_168 + __v_173);
-    let __v_175: G = (__v_166 + __v_174);
-    let __v_176: G = (__v_164 + __v_175);
-    let __v_177: G = (__v_162 + __v_176);
-    let __v_178: G = (__v_160 + __v_177);
-    let __v_179: G = (__v_59 + __v_178);
-    let __v_180: G = G::from_u64(256);
-    let __v_181: G = (__v_180 * __v_68);
-    let __v_182: G = G::from_u64(65536);
-    let __v_183: G = (__v_182 * __v_69);
-    let __v_184: G = G::from_u64(16777216);
-    let __v_185: G = (__v_184 * __v_70);
-    let __v_186: G = G::from_u64(4294967296);
-    let __v_187: G = (__v_186 * __v_71);
-    let __v_188: G = G::from_u64(1099511627776);
-    let __v_189: G = (__v_188 * __v_72);
-    let __v_190: G = G::from_u64(281474976710656);
-    let __v_191: G = (__v_190 * __v_73);
-    let __v_192: G = G::from_u64(72057594037927936);
-    let __v_193: G = (__v_192 * __v_74);
-    let __v_194: G = (__v_191 + __v_193);
-    let __v_195: G = (__v_189 + __v_194);
-    let __v_196: G = (__v_187 + __v_195);
-    let __v_197: G = (__v_185 + __v_196);
-    let __v_198: G = (__v_183 + __v_197);
-    let __v_199: G = (__v_181 + __v_198);
-    let __v_200: G = (__v_67 + __v_199);
-    let __v_201: G = G::from_u64(256);
-    let __v_202: G = (__v_201 * __v_87);
-    let __v_203: G = G::from_u64(65536);
-    let __v_204: G = (__v_203 * __v_88);
-    let __v_205: G = G::from_u64(16777216);
-    let __v_206: G = (__v_205 * __v_89);
-    let __v_207: G = G::from_u64(4294967296);
-    let __v_208: G = (__v_207 * __v_90);
-    let __v_209: G = G::from_u64(1099511627776);
-    let __v_210: G = (__v_209 * __v_91);
-    let __v_211: G = G::from_u64(281474976710656);
-    let __v_212: G = (__v_211 * __v_92);
-    let __v_213: G = G::from_u64(72057594037927936);
-    let __v_214: G = (__v_213 * __v_93);
-    let __v_215: G = (__v_212 + __v_214);
-    let __v_216: G = (__v_210 + __v_215);
-    let __v_217: G = (__v_208 + __v_216);
-    let __v_218: G = (__v_206 + __v_217);
-    let __v_219: G = (__v_204 + __v_218);
-    let __v_220: G = (__v_202 + __v_219);
-    let __v_221: G = (__v_86 + __v_220);
-    let __v_222: G = G::from_u64(256);
-    let __v_223: G = (__v_222 * __v_95);
-    let __v_224: G = G::from_u64(65536);
-    let __v_225: G = (__v_224 * __v_96);
-    let __v_226: G = G::from_u64(16777216);
-    let __v_227: G = (__v_226 * __v_97);
-    let __v_228: G = G::from_u64(4294967296);
-    let __v_229: G = (__v_228 * __v_98);
-    let __v_230: G = G::from_u64(1099511627776);
-    let __v_231: G = (__v_230 * __v_99);
-    let __v_232: G = G::from_u64(281474976710656);
-    let __v_233: G = (__v_232 * __v_100);
-    let __v_234: G = G::from_u64(72057594037927936);
-    let __v_235: G = (__v_234 * __v_101);
-    let __v_236: G = (__v_233 + __v_235);
-    let __v_237: G = (__v_231 + __v_236);
-    let __v_238: G = (__v_229 + __v_237);
-    let __v_239: G = (__v_227 + __v_238);
-    let __v_240: G = (__v_225 + __v_239);
-    let __v_241: G = (__v_223 + __v_240);
-    let __v_242: G = (__v_94 + __v_241);
-    let __v_243: G = G::from_u64(256);
-    let __v_244: G = (__v_243 * __v_120);
-    let __v_245: G = G::from_u64(65536);
-    let __v_246: G = (__v_245 * __v_121);
-    let __v_247: G = G::from_u64(16777216);
-    let __v_248: G = (__v_247 * __v_122);
-    let __v_249: G = G::from_u64(4294967296);
-    let __v_250: G = (__v_249 * __v_123);
-    let __v_251: G = G::from_u64(1099511627776);
-    let __v_252: G = (__v_251 * __v_124);
-    let __v_253: G = G::from_u64(281474976710656);
-    let __v_254: G = (__v_253 * __v_125);
-    let __v_255: G = G::from_u64(72057594037927936);
-    let __v_256: G = (__v_255 * __v_126);
-    let __v_257: G = (__v_254 + __v_256);
-    let __v_258: G = (__v_252 + __v_257);
-    let __v_259: G = (__v_250 + __v_258);
-    let __v_260: G = (__v_248 + __v_259);
-    let __v_261: G = (__v_246 + __v_260);
-    let __v_262: G = (__v_244 + __v_261);
-    let __v_263: G = (__v_119 + __v_262);
-    let __v_264: G = G::from_u64(256);
-    let __v_265: G = (__v_264 * __v_128);
-    let __v_266: G = G::from_u64(65536);
-    let __v_267: G = (__v_266 * __v_129);
-    let __v_268: G = G::from_u64(16777216);
-    let __v_269: G = (__v_268 * __v_130);
-    let __v_270: G = G::from_u64(4294967296);
-    let __v_271: G = (__v_270 * __v_131);
-    let __v_272: G = G::from_u64(1099511627776);
-    let __v_273: G = (__v_272 * __v_132);
-    let __v_274: G = G::from_u64(281474976710656);
-    let __v_275: G = (__v_274 * __v_133);
-    let __v_276: G = G::from_u64(72057594037927936);
-    let __v_277: G = (__v_276 * __v_134);
-    let __v_278: G = (__v_275 + __v_277);
-    let __v_279: G = (__v_273 + __v_278);
-    let __v_280: G = (__v_271 + __v_279);
-    let __v_281: G = (__v_269 + __v_280);
-    let __v_282: G = (__v_267 + __v_281);
-    let __v_283: G = (__v_265 + __v_282);
-    let __v_284: G = (__v_127 + __v_283);
-    let __v_285: G = G::from_u64(256);
-    let __v_286: G = (__v_285 * __v_142);
-    let __v_287: G = G::from_u64(65536);
-    let __v_288: G = (__v_287 * __v_143);
-    let __v_289: G = G::from_u64(16777216);
-    let __v_290: G = (__v_289 * __v_144);
-    let __v_291: G = G::from_u64(4294967296);
-    let __v_292: G = (__v_291 * __v_145);
-    let __v_293: G = G::from_u64(1099511627776);
-    let __v_294: G = (__v_293 * __v_146);
-    let __v_295: G = G::from_u64(281474976710656);
-    let __v_296: G = (__v_295 * __v_147);
-    let __v_297: G = G::from_u64(72057594037927936);
-    let __v_298: G = (__v_297 * __v_148);
-    let __v_299: G = (__v_296 + __v_298);
-    let __v_300: G = (__v_294 + __v_299);
-    let __v_301: G = (__v_292 + __v_300);
-    let __v_302: G = (__v_290 + __v_301);
-    let __v_303: G = (__v_288 + __v_302);
-    let __v_304: G = (__v_286 + __v_303);
-    let __v_305: G = (__v_141 + __v_304);
-    let __v_306: G = G::from_u64(256);
-    let __v_307: G = (__v_306 * __v_150);
-    let __v_308: G = G::from_u64(65536);
-    let __v_309: G = (__v_308 * __v_151);
-    let __v_310: G = G::from_u64(16777216);
-    let __v_311: G = (__v_310 * __v_152);
-    let __v_312: G = G::from_u64(4294967296);
-    let __v_313: G = (__v_312 * __v_153);
-    let __v_314: G = G::from_u64(1099511627776);
-    let __v_315: G = (__v_314 * __v_154);
-    let __v_316: G = G::from_u64(281474976710656);
-    let __v_317: G = (__v_316 * __v_155);
-    let __v_318: G = G::from_u64(72057594037927936);
-    let __v_319: G = (__v_318 * __v_156);
-    let __v_320: G = (__v_317 + __v_319);
-    let __v_321: G = (__v_315 + __v_320);
-    let __v_322: G = (__v_313 + __v_321);
-    let __v_323: G = (__v_311 + __v_322);
-    let __v_324: G = (__v_309 + __v_323);
-    let __v_325: G = (__v_307 + __v_324);
-    let __v_326: G = (__v_149 + __v_325);
-    let __ret: [G; OUT_160] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
-    if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    match __v_6.as_canonical_u64() {
+      _ => {
+        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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+        let __v_33: G = G::from_u64(1);
+        let __v_34: G = G::from_u64(1);
+        let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() {
+  0u64 => {
+    break '__mc_0 [__v_35];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5, __v_35]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+    break '__mc_0 [__v_36];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+  },
+}
+ };
+        let __v_36: G = __mc_out___mc_0[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_36]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_37]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_38]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_39]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __v_41: G = G::from_u64(1);
+        let __v_42: G = G::from_u64(1);
+        let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_40, __v_43]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __v_46: G = __r_arr[2];
+        let __v_47: G = __r_arr[3];
+        let __v_48: G = __r_arr[4];
+        let __v_49: G = __r_arr[5];
+        let __v_50: G = __r_arr[6];
+        let __v_51: G = __r_arr[7];
+        let __v_52: G = __r_arr[8];
+        let __v_53: G = __r_arr[9];
+        let __v_54: G = __r_arr[10];
+        let __v_55: G = __r_arr[11];
+        let __v_56: G = __r_arr[12];
+        let __v_57: G = __r_arr[13];
+        let __v_58: G = __r_arr[14];
+        let __v_59: G = __r_arr[15];
+        let __v_60: G = __r_arr[16];
+        let __v_61: G = __r_arr[17];
+        let __v_62: G = G::from_u64(256);
+        let __v_63: G = (__v_62 * __v_45);
+        let __v_64: G = G::from_u64(65536);
+        let __v_65: G = (__v_64 * __v_46);
+        let __v_66: G = G::from_u64(16777216);
+        let __v_67: G = (__v_66 * __v_47);
+        let __v_68: G = G::from_u64(4294967296);
+        let __v_69: G = (__v_68 * __v_48);
+        let __v_70: G = G::from_u64(1099511627776);
+        let __v_71: G = (__v_70 * __v_49);
+        let __v_72: G = G::from_u64(281474976710656);
+        let __v_73: G = (__v_72 * __v_50);
+        let __v_74: G = G::from_u64(72057594037927936);
+        let __v_75: G = (__v_74 * __v_51);
+        let __v_76: G = (__v_73 + __v_75);
+        let __v_77: G = (__v_71 + __v_76);
+        let __v_78: G = (__v_69 + __v_77);
+        let __v_79: G = (__v_67 + __v_78);
+        let __v_80: G = (__v_65 + __v_79);
+        let __v_81: G = (__v_63 + __v_80);
+        let __v_82: G = (__v_44 + __v_81);
+        let __v_83: G = G::from_u64(256);
+        let __v_84: G = (__v_83 * __v_53);
+        let __v_85: G = G::from_u64(65536);
+        let __v_86: G = (__v_85 * __v_54);
+        let __v_87: G = G::from_u64(16777216);
+        let __v_88: G = (__v_87 * __v_55);
+        let __v_89: G = G::from_u64(4294967296);
+        let __v_90: G = (__v_89 * __v_56);
+        let __v_91: G = G::from_u64(1099511627776);
+        let __v_92: G = (__v_91 * __v_57);
+        let __v_93: G = G::from_u64(281474976710656);
+        let __v_94: G = (__v_93 * __v_58);
+        let __v_95: G = G::from_u64(72057594037927936);
+        let __v_96: G = (__v_95 * __v_59);
+        let __v_97: G = (__v_94 + __v_96);
+        let __v_98: G = (__v_92 + __v_97);
+        let __v_99: G = (__v_90 + __v_98);
+        let __v_100: G = (__v_88 + __v_99);
+        let __v_101: G = (__v_86 + __v_100);
+        let __v_102: G = (__v_84 + __v_101);
+        let __v_103: G = (__v_52 + __v_102);
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_60, __v_6, __v_7, __v_30]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
+        let __v_106: G = G::from_u64(1);
+        let __v_107: G = G::from_u64(1);
+        let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10, __v_108]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_109: G = __r_arr[0];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_105, __v_109]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_110: G = __r_arr[0];
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_110, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_111: G = __r_arr[0];
+        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+        let __v_113: G = __r_arr[1];
+        let __v_114: G = (__v_32 + __v_28);
+        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_29, __v_114]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_115: G = __r_arr[0];
+        let __v_116: G = G::from_u64(0);
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_8, __v_9, __v_116, __v_29]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_117: G = __r_arr[0];
+        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+        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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+        let __v_120: G = (__v_119 - __v_32);
+        let __v_121: G = G::from_bool((__v_120 == G::ZERO));
+        let __v_122: G = G::from_u64(1);
+        if (__v_121 != __v_122) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+        let __v_124: G = G::from_u64(3);
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_4, __v_5]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_125: G = __r_arr[0];
+        let __v_126: G = (__v_124 + __v_125);
+        if (__v_123 != __v_126) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_9]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_127: G = __r_arr[0];
+        let __v_128: G = (__v_127 - __v_32);
+        let __v_129: G = G::from_bool((__v_128 == G::ZERO));
+        let __v_130: G = G::from_u64(1);
+        if (__v_129 != __v_130) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_131: G = __r_arr[0];
+        let __v_132: G = G::from_u64(1);
+        if (__v_131 != __v_132) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None });
+        }
+        let __v_133: G = G::from_u64(33);
+        let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+        let __v_135: G = G::from_u64(1);
+        if (__v_134 != __v_135) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_136: G = __r_arr[0];
+        let __v_137: G = G::from_u64(1);
+        if (__v_136 != __v_137) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None });
+        }
+        let __v_138: G = G::from_u64(0);
+        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_139: G = __r_arr[0];
+        let __ret: [G; OUT_158] = [__v_139];
+        if !unconstrained { record.virt += record.function_queries[158].weight(); } record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
   })
 }
 
-const INPUT_SIZE_161: usize = 3;
-const IN_161: usize = 3;
-const OUT_161: usize = 2;
-fn aiur_fn_161(
-  inp: [G; IN_161],
+const INPUT_SIZE_159: usize = 2;
+const IN_159: usize = 2;
+const OUT_159: usize = 1;
+fn aiur_fn_159(
+  inp: [G; IN_159],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_161], ExecError> {
+) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     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_161] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_3: G = (__v_0 * __v_0);
-        let __v_4: G = G::from_u64(7);
-        let __v_5: G = (__v_1 * __v_1);
-        let __v_6: G = (__v_4 * __v_5);
-        let __v_7: G = (__v_3 + __v_6);
-        let __v_8: G = (__v_0 * __v_1);
-        let __v_9: G = (__v_1 * __v_0);
-        let __v_10: G = (__v_8 + __v_9);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = (__v_2 - __v_11);
-        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_161] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
+    let __v_2: G = G::from_bool((__v_0 == G::ZERO));
+    let __v_3: G = G::from_bool((__v_1 == G::ZERO));
+    let __v_4: G = (__v_2 * __v_3);
+    let __ret: [G; OUT_159] = [__v_4];
+    if !unconstrained { record.virt += record.function_queries[159].weight(); } record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_162: usize = 1;
-const IN_162: usize = 1;
-const OUT_162: usize = 1;
-fn aiur_fn_162(
-  inp: [G; IN_162],
+const INPUT_SIZE_160: usize = 1;
+const IN_160: usize = 1;
+const OUT_160: usize = 1;
+fn aiur_fn_160(
+  inp: [G; IN_160],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_162], ExecError> {
+) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      32u64 => {
-        let __v_1: G = G::from_u64(1753635133440165772);
-        let __ret: [G; OUT_162] = [__v_1];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_1: G = G::from_u64(1);
-        let __v_2: G = (__v_0 + __v_1);
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-        let __v_3: G = __r_arr[0];
-        let __v_4: G = (__v_3 * __v_3);
-        let __ret: [G; OUT_162] = [__v_4];
-        if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_160] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-    }
-  })
-}
-
-const INPUT_SIZE_163: usize = 3;
-const IN_163: usize = 3;
-const OUT_163: usize = 2;
-fn aiur_fn_163(
-  inp: [G; IN_163],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_163], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = (__v_3 - __v_5);
-    let __v_8: G = (__v_4 - __v_6);
-    let __ret: [G; OUT_163] = [__v_7, __v_8];
-    if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_164: usize = 1;
-const IN_164: usize = 1;
-const OUT_164: usize = 1;
-fn aiur_fn_164(
-  inp: [G; IN_164],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_164], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_164] = [__v_1];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_9: G = G::from_bool((__v_2 == G::ZERO));
+            let __v_10: G = G::from_bool((__v_3 == G::ZERO));
+            let __v_11: G = (__v_9 * __v_10);
+            let __ret: [G; OUT_160] = [__v_11];
+            if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __ret: [G; OUT_160] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[160].weight(); } record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
       },
       _ => {
-        let __v_1: G = G::from_u64(2);
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = (__v_0 - __v_2);
-        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = (__v_1 * __v_4);
-        let __ret: [G; OUT_164] = [__v_5];
-        if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_165: usize = 3;
-const IN_165: usize = 3;
-const OUT_165: usize = 8;
-fn aiur_fn_165(
-  inp: [G; IN_165],
+const INPUT_SIZE_161: usize = 9;
+const IN_161: usize = 9;
+const OUT_161: usize = 1;
+fn aiur_fn_161(
+  inp: [G; IN_161],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_165], ExecError> {
+) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = G::from_u64(0);
-    let __v_7: G = (__v_3 - __v_5);
-    let __v_8: G = (__v_4 - __v_6);
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-    let __v_9: G = __r_arr[0];
-    let __v_10: G = g_inverse_value(__v_9);
-    let __v_11: G = (__v_9 * __v_10);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = (__v_11 - __v_12);
-    let __v_14: G = (__v_9 * __v_13);
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
     let __v_15: G = G::from_u64(0);
-    if (__v_14 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
-    }
-    let __v_16: G = (__v_10 * __v_13);
-    let __v_17: G = G::from_u64(0);
-    if (__v_16 != __v_17) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
-    }
-    let __v_18: G = G::from_u64(1);
-    let __v_19: G = G::from_u64(0);
-    let __v_20: G = (__v_0 - __v_18);
-    let __v_21: G = (__v_1 - __v_19);
-    let __v_22: G = (__v_20 * __v_20);
-    let __v_23: G = G::from_u64(7);
-    let __v_24: G = (__v_21 * __v_21);
-    let __v_25: G = (__v_23 * __v_24);
-    let __v_26: G = (__v_22 - __v_25);
-    let __v_27: G = g_inverse_value(__v_26);
-    let __v_28: G = (__v_26 * __v_27);
-    let __v_29: G = G::from_u64(1);
-    let __v_30: G = (__v_28 - __v_29);
-    let __v_31: G = (__v_26 * __v_30);
-    let __v_32: G = G::from_u64(0);
-    if (__v_31 != __v_32) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
-    }
-    let __v_33: G = (__v_27 * __v_30);
-    let __v_34: G = G::from_u64(0);
-    if (__v_33 != __v_34) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
-    }
-    let __v_35: G = (__v_20 * __v_27);
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = (__v_36 - __v_21);
-    let __v_38: G = (__v_37 * __v_27);
-    let __v_39: G = (__v_7 * __v_35);
-    let __v_40: G = G::from_u64(7);
-    let __v_41: G = (__v_8 * __v_38);
-    let __v_42: G = (__v_40 * __v_41);
-    let __v_43: G = (__v_39 + __v_42);
-    let __v_44: G = (__v_7 * __v_38);
-    let __v_45: G = (__v_8 * __v_35);
-    let __v_46: G = (__v_44 + __v_45);
-    let __v_47: G = G::from_u64(0);
-    let __v_48: G = (__v_0 - __v_10);
-    let __v_49: G = (__v_1 - __v_47);
-    let __v_50: G = (__v_48 * __v_48);
-    let __v_51: G = G::from_u64(7);
-    let __v_52: G = (__v_49 * __v_49);
-    let __v_53: G = (__v_51 * __v_52);
-    let __v_54: G = (__v_50 - __v_53);
-    let __v_55: G = g_inverse_value(__v_54);
-    let __v_56: G = (__v_54 * __v_55);
-    let __v_57: G = G::from_u64(1);
-    let __v_58: G = (__v_56 - __v_57);
-    let __v_59: G = (__v_54 * __v_58);
-    let __v_60: G = G::from_u64(0);
-    if (__v_59 != __v_60) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-    }
-    let __v_61: G = (__v_55 * __v_58);
-    let __v_62: G = G::from_u64(0);
-    if (__v_61 != __v_62) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
-    }
-    let __v_63: G = (__v_48 * __v_55);
-    let __v_64: G = G::from_u64(0);
-    let __v_65: G = (__v_64 - __v_49);
-    let __v_66: G = (__v_65 * __v_55);
-    let __v_67: G = (__v_7 * __v_63);
-    let __v_68: G = G::from_u64(7);
-    let __v_69: G = (__v_8 * __v_66);
-    let __v_70: G = (__v_68 * __v_69);
-    let __v_71: G = (__v_67 + __v_70);
-    let __v_72: G = (__v_7 * __v_66);
-    let __v_73: G = (__v_8 * __v_63);
-    let __v_74: G = (__v_72 + __v_73);
-    let __v_75: G = G::from_u64(0);
-    let __v_76: G = (__v_0 - __v_10);
-    let __v_77: G = (__v_1 - __v_75);
-    let __v_78: G = (__v_7 * __v_7);
-    let __v_79: G = G::from_u64(7);
-    let __v_80: G = (__v_8 * __v_8);
-    let __v_81: G = (__v_79 * __v_80);
-    let __v_82: G = (__v_78 - __v_81);
-    let __v_83: G = g_inverse_value(__v_82);
-    let __v_84: G = (__v_82 * __v_83);
-    let __v_85: G = G::from_u64(1);
-    let __v_86: G = (__v_84 - __v_85);
-    let __v_87: G = (__v_82 * __v_86);
-    let __v_88: G = G::from_u64(0);
-    if (__v_87 != __v_88) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
-    }
-    let __v_89: G = (__v_83 * __v_86);
-    let __v_90: G = G::from_u64(0);
-    if (__v_89 != __v_90) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
-    }
-    let __v_91: G = (__v_7 * __v_83);
-    let __v_92: G = G::from_u64(0);
-    let __v_93: G = (__v_92 - __v_8);
-    let __v_94: G = (__v_93 * __v_83);
-    let __ret: [G; OUT_165] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
-    if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_161] = [__v_24];
+    if !unconstrained { record.virt += record.function_queries[161].weight(); } record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_166: usize = 23;
-const IN_166: usize = 23;
-const OUT_166: usize = 1;
-fn aiur_fn_166(
-  inp: [G; IN_166],
+const INPUT_SIZE_162: usize = 33;
+const IN_162: usize = 33;
+const OUT_162: usize = 1;
+fn aiur_fn_162(
+  inp: [G; IN_162],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_166], ExecError> {
+) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -15410,960 +15480,708 @@ fn aiur_fn_166(
     let __v_20: G = inp[20];
     let __v_21: G = inp[21];
     let __v_22: G = inp[22];
-    match __v_0.as_canonical_u64() {
-      _ => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __v_24: G = G::from_bool((__v_23 == G::ZERO));
-        let __v_25: G = G::from_u64(0);
-        if (__v_24 != __v_25) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        if (__v_26 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_27: G = __r_arr[0];
-        if (__v_27 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-        let __v_28: G = __r_arr[0];
-        if (__v_28 != __v_23) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-        let __v_29: G = __r_arr[0];
-        let __v_30: G = G::from_u64(1);
-        if (__v_29 != __v_30) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
-        }
-        let __v_31: G = G::from_u64(1);
-        let __ret: [G; OUT_166] = [__v_31];
-        if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_167: usize = 6;
-const IN_167: usize = 6;
-const OUT_167: usize = 2;
-fn aiur_fn_167(
-  inp: [G; IN_167],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_167], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __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 = (__v_0 * __v_2);
-    let __v_7: G = G::from_u64(7);
-    let __v_8: G = (__v_1 * __v_3);
-    let __v_9: G = (__v_7 * __v_8);
-    let __v_10: G = (__v_6 + __v_9);
-    let __v_11: G = (__v_0 * __v_3);
-    let __v_12: G = (__v_1 * __v_2);
-    let __v_13: G = (__v_11 + __v_12);
-    let __v_14: G = (__v_10 + __v_4);
-    let __v_15: G = (__v_13 + __v_5);
-    let __ret: [G; OUT_167] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+    let __ret: [G; OUT_162] = [__v_36];
+    if !unconstrained { record.virt += record.function_queries[162].weight(); } record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_168: usize = 4;
-const IN_168: usize = 4;
-const OUT_168: usize = 2;
-fn aiur_fn_168(
-  inp: [G; IN_168],
+const INPUT_SIZE_163: usize = 2;
+const IN_163: usize = 2;
+const OUT_163: usize = 1;
+fn aiur_fn_163(
+  inp: [G; IN_163],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_168], ExecError> {
+) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = G::from_u64(0);
-    let __v_5: G = G::from_u64(1);
-    let __v_6: G = (__v_2 * __v_4);
-    let __v_7: G = G::from_u64(7);
-    let __v_8: G = (__v_3 * __v_5);
-    let __v_9: G = (__v_7 * __v_8);
-    let __v_10: G = (__v_6 + __v_9);
-    let __v_11: G = (__v_2 * __v_5);
-    let __v_12: G = (__v_3 * __v_4);
-    let __v_13: G = (__v_11 + __v_12);
-    let __v_14: G = (__v_0 + __v_10);
-    let __v_15: G = (__v_1 + __v_13);
-    let __ret: [G; OUT_168] = [__v_14, __v_15];
-    if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_169: usize = 1;
-const IN_169: usize = 1;
-const OUT_169: usize = 1;
-fn aiur_fn_169(
-  inp: [G; IN_169],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_169], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    match __v_1.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_169] = [__v_7];
-        if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_163] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
-        match __v_5.as_canonical_u64() {
-          0u64 => {
-            let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } };
-            let __v_10: G = __r_arr[0];
-            let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
-            let __v_12: G = __r_arr[0];
-            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_169] = [__v_13];
-            if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
-          },
-        }
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
+        let __v_15: G = __loaded[10];
+        let __v_16: G = __loaded[11];
+        let __v_17: G = __loaded[12];
+        let __v_18: G = __loaded[13];
+        let __v_19: G = __loaded[14];
+        let __v_20: G = __loaded[15];
+        let __v_21: G = __loaded[16];
+        let __v_22: G = __loaded[17];
+        let __v_23: G = __loaded[18];
+        let __v_24: G = __loaded[19];
+        let __v_25: G = __loaded[20];
+        let __v_26: G = __loaded[21];
+        let __v_27: G = __loaded[22];
+        let __v_28: G = __loaded[23];
+        let __v_29: G = __loaded[24];
+        let __v_30: G = __loaded[25];
+        let __v_31: G = __loaded[26];
+        let __v_32: G = __loaded[27];
+        let __v_33: G = __loaded[28];
+        let __v_34: G = __loaded[29];
+        let __v_35: G = __loaded[30];
+        let __v_36: G = __loaded[31];
+        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+        let __ret: [G; OUT_163] = [__v_41];
+        if !unconstrained { record.virt += record.function_queries[163].weight(); } record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_170: usize = 15;
-const IN_170: usize = 15;
-const OUT_170: usize = 2;
-fn aiur_fn_170(
-  inp: [G; IN_170],
+const INPUT_SIZE_164: usize = 2;
+const IN_164: usize = 2;
+const OUT_164: usize = 1;
+fn aiur_fn_164(
+  inp: [G; IN_164],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_170], ExecError> {
+) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } };
-    let __v_15: G = __r_arr[0];
-    let __v_16: G = __r_arr[1];
-    let __v_17: G = __r_arr[2];
-    let __v_18: G = __r_arr[3];
-    match __v_15.as_canonical_u64() {
-      0u64 => {
-        let __v_19: G = G::from_u64(0);
-        let __ret: [G; OUT_170] = [__v_16, __v_19];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_19: G = (__v_16 + __v_17);
-        let __v_20: G = (__v_16 + __v_19);
-        match __v_20.as_canonical_u64() {
-          0u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_21: G = __r_arr[0];
-            let __v_22: G = __r_arr[1];
-            let __ret: [G; OUT_170] = [__v_21, __v_22];
-            if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-        }
-      },
-      2u64 => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __ret: [G; OUT_170] = [__v_19, __v_20];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __ret: [G; OUT_170] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __ret: [G; OUT_170] = [__v_11, __v_12];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __ret: [G; OUT_170] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = __r_arr[1];
-        let __v_23: G = (__v_19 + __v_21);
-        let __v_24: G = (__v_20 + __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_164] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      7u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = __r_arr[1];
-        let __v_23: G = (__v_19 - __v_21);
-        let __v_24: G = (__v_20 - __v_22);
-        let __ret: [G; OUT_170] = [__v_23, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+      0u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(0);
+        let __v_7: G = G::from_u64(0);
+        let __v_8: G = G::from_u64(0);
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __v_11: G = G::from_u64(0);
+        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __ret: [G; OUT_164] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[164].weight(); } record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      8u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_21: G = __r_arr[0];
-        let __v_22: G = __r_arr[1];
-        let __v_23: G = (__v_19 * __v_21);
-        let __v_24: G = G::from_u64(7);
-        let __v_25: G = (__v_20 * __v_22);
-        let __v_26: G = (__v_24 * __v_25);
-        let __v_27: G = (__v_23 + __v_26);
-        let __v_28: G = (__v_19 * __v_22);
-        let __v_29: G = (__v_20 * __v_21);
-        let __v_30: G = (__v_28 + __v_29);
-        let __ret: [G; OUT_170] = [__v_27, __v_30];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      9u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_19: G = __r_arr[0];
-        let __v_20: G = __r_arr[1];
-        let __v_21: G = G::from_u64(0);
-        let __v_22: G = (__v_21 - __v_19);
-        let __v_23: G = G::from_u64(0);
-        let __v_24: G = (__v_23 - __v_20);
-        let __ret: [G; OUT_170] = [__v_22, __v_24];
-        if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_171: usize = 19;
-const IN_171: usize = 19;
-const OUT_171: usize = 2;
-fn aiur_fn_171(
-  inp: [G; IN_171],
+const INPUT_SIZE_165: usize = 2;
+const IN_165: usize = 2;
+const OUT_165: usize = 10;
+fn aiur_fn_165(
+  inp: [G; IN_165],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_171], ExecError> {
+) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_19: G = __loaded[0];
-    let __v_20: G = __loaded[1];
-    let __v_21: G = __loaded[2];
-    match __v_19.as_canonical_u64() {
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_171] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
+        let __v_5: G = G::from_u64(103);
+        let __v_6: G = G::from_u64(230);
+        let __v_7: G = G::from_u64(9);
+        let __v_8: G = G::from_u64(106);
+        let __v_9: G = G::from_u64(133);
+        let __v_10: G = G::from_u64(174);
+        let __v_11: G = G::from_u64(103);
+        let __v_12: G = G::from_u64(187);
+        let __v_13: G = G::from_u64(114);
+        let __v_14: G = G::from_u64(243);
+        let __v_15: G = G::from_u64(110);
+        let __v_16: G = G::from_u64(60);
+        let __v_17: G = G::from_u64(58);
+        let __v_18: G = G::from_u64(245);
+        let __v_19: G = G::from_u64(79);
+        let __v_20: G = G::from_u64(165);
+        let __v_21: G = G::from_u64(127);
+        let __v_22: G = G::from_u64(82);
+        let __v_23: G = G::from_u64(14);
+        let __v_24: G = G::from_u64(81);
+        let __v_25: G = G::from_u64(140);
+        let __v_26: G = G::from_u64(104);
+        let __v_27: G = G::from_u64(5);
+        let __v_28: G = G::from_u64(155);
+        let __v_29: G = G::from_u64(171);
+        let __v_30: G = G::from_u64(217);
+        let __v_31: G = G::from_u64(131);
+        let __v_32: G = G::from_u64(31);
+        let __v_33: G = G::from_u64(25);
+        let __v_34: G = G::from_u64(205);
+        let __v_35: G = G::from_u64(224);
+        let __v_36: G = G::from_u64(91);
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_40: G = G::from_u64(0);
+        let __v_41: G = G::from_u64(0);
+        let __v_42: G = G::from_u64(0);
+        let __v_43: G = G::from_u64(0);
+        let __v_44: G = G::from_u64(0);
+        let __v_45: G = G::from_u64(0);
+        let __v_46: G = G::from_u64(0);
+        let __v_47: G = G::from_u64(0);
+        let __v_48: G = G::from_u64(0);
+        let __v_49: G = G::from_u64(0);
+        let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_52: G = G::from_u64(1);
+        let __v_53: G = G::from_u64(1);
+        let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_55: G = __r_arr[0];
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
+        let __v_57: G = __r_arr[1];
+        let __v_58: G = __r_arr[2];
+        let __v_59: G = __r_arr[3];
+        let __v_60: G = __r_arr[4];
+        let __v_61: G = __r_arr[5];
+        let __v_62: G = __r_arr[6];
+        let __v_63: G = __r_arr[7];
+        let __v_64: G = __r_arr[8];
+        let __v_65: G = __r_arr[9];
+        let __v_66: G = __r_arr[10];
+        let __v_67: G = __r_arr[11];
+        let __v_68: G = __r_arr[12];
+        let __v_69: G = __r_arr[13];
+        let __v_70: G = __r_arr[14];
+        let __v_71: G = __r_arr[15];
+        let __v_72: G = __r_arr[16];
+        let __v_73: G = __r_arr[17];
+        let __v_74: G = __r_arr[18];
+        let __v_75: G = __r_arr[19];
+        let __v_76: G = __r_arr[20];
+        let __v_77: G = __r_arr[21];
+        let __v_78: G = __r_arr[22];
+        let __v_79: G = __r_arr[23];
+        let __v_80: G = __r_arr[24];
+        let __v_81: G = __r_arr[25];
+        let __v_82: G = __r_arr[26];
+        let __v_83: G = __r_arr[27];
+        let __v_84: G = __r_arr[28];
+        let __v_85: G = __r_arr[29];
+        let __v_86: G = __r_arr[30];
+        let __v_87: G = __r_arr[31];
+        let __v_88: G = G::from_u64(1);
+        let __v_89: G = G::from_u64(1);
+        let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_91: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_92: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_93: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_94: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_95: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_96: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_97: G = __r_arr[0];
+        let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[98].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } };
+        let __v_98: G = __r_arr[0];
+        let __v_99: G = G::from_u64(1);
+        let __v_100: G = G::from_u64(1);
+        let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_98, __v_101]; 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 { let __r = record.function_queries[118].replay_at(__i); record.virt += __r; } 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 __v_102: 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_102.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_103: G = __loaded[0];
+        let __v_104: G = __loaded[1];
+        let __v_105: G = __loaded[2];
+        match __v_103.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_106: G = __loaded[0];
+            let __v_107: G = __loaded[1];
+            let __v_108: G = __loaded[2];
+            match __v_106.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_109: G = __loaded[0];
+                let __v_110: G = __loaded[1];
+                let __v_111: G = __loaded[2];
+                match __v_109.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_112: G = __loaded[0];
+                    let __v_113: G = __loaded[1];
+                    let __v_114: G = __loaded[2];
+                    match __v_112.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_115: G = __loaded[0];
+                        let __v_116: G = __loaded[1];
+                        let __v_117: G = __loaded[2];
+                        match __v_115.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_118: G = __loaded[0];
+                            let __v_119: G = __loaded[1];
+                            let __v_120: G = __loaded[2];
+                            match __v_118.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_121: G = __loaded[0];
+                                let __v_122: G = __loaded[1];
+                                let __v_123: G = __loaded[2];
+                                match __v_121.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                    let __v_124: G = __loaded[0];
+                                    let __v_125: G = __loaded[1];
+                                    let __v_126: G = __loaded[2];
+                                    match __v_124.as_canonical_u64() {
+                                      0u64 => {
+                                        let __ret: [G; OUT_165] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126];
+                                        if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64()));
+          },
+        }
       },
       0u64 => {
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = __r_arr[1];
-        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = __r_arr[1];
-        let __ret: [G; OUT_171] = [__v_26, __v_27];
-        if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_172: usize = 8;
-const IN_172: usize = 8;
-const OUT_172: usize = 4;
-fn aiur_fn_172(
-  inp: [G; IN_172],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_172], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    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 = (__v_0 * __v_4);
-    let __v_9: G = G::from_u64(7);
-    let __v_10: G = (__v_1 * __v_5);
-    let __v_11: G = (__v_9 * __v_10);
-    let __v_12: G = (__v_8 + __v_11);
-    let __v_13: G = (__v_0 * __v_5);
-    let __v_14: G = (__v_1 * __v_4);
-    let __v_15: G = (__v_13 + __v_14);
-    let __v_16: G = G::from_u64(7);
-    let __v_17: G = G::from_u64(0);
-    let __v_18: G = (__v_2 * __v_6);
-    let __v_19: G = G::from_u64(7);
-    let __v_20: G = (__v_3 * __v_7);
-    let __v_21: G = (__v_19 * __v_20);
-    let __v_22: G = (__v_18 + __v_21);
-    let __v_23: G = (__v_2 * __v_7);
-    let __v_24: G = (__v_3 * __v_6);
-    let __v_25: G = (__v_23 + __v_24);
-    let __v_26: G = (__v_16 * __v_22);
-    let __v_27: G = G::from_u64(7);
-    let __v_28: G = (__v_17 * __v_25);
-    let __v_29: G = (__v_27 * __v_28);
-    let __v_30: G = (__v_26 + __v_29);
-    let __v_31: G = (__v_16 * __v_25);
-    let __v_32: G = (__v_17 * __v_22);
-    let __v_33: G = (__v_31 + __v_32);
-    let __v_34: G = (__v_0 * __v_6);
-    let __v_35: G = G::from_u64(7);
-    let __v_36: G = (__v_1 * __v_7);
-    let __v_37: G = (__v_35 * __v_36);
-    let __v_38: G = (__v_34 + __v_37);
-    let __v_39: G = (__v_0 * __v_7);
-    let __v_40: G = (__v_1 * __v_6);
-    let __v_41: G = (__v_39 + __v_40);
-    let __v_42: G = (__v_2 * __v_4);
-    let __v_43: G = G::from_u64(7);
-    let __v_44: G = (__v_3 * __v_5);
-    let __v_45: G = (__v_43 * __v_44);
-    let __v_46: G = (__v_42 + __v_45);
-    let __v_47: G = (__v_2 * __v_5);
-    let __v_48: G = (__v_3 * __v_4);
-    let __v_49: G = (__v_47 + __v_48);
-    let __v_50: G = (__v_12 + __v_30);
-    let __v_51: G = (__v_15 + __v_33);
-    let __v_52: G = (__v_38 + __v_46);
-    let __v_53: G = (__v_41 + __v_49);
-    let __ret: [G; OUT_172] = [__v_50, __v_51, __v_52, __v_53];
-    if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_8: G = __loaded[0];
+            let __v_9: G = __loaded[1];
+            let __v_10: G = __loaded[2];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_11: G = __loaded[0];
+                let __v_12: G = __loaded[1];
+                let __v_13: G = __loaded[2];
+                match __v_11.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_14: G = __loaded[0];
+                    let __v_15: G = __loaded[1];
+                    let __v_16: G = __loaded[2];
+                    match __v_14.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_17: G = __loaded[0];
+                        let __v_18: G = __loaded[1];
+                        let __v_19: G = __loaded[2];
+                        match __v_17.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                            let __v_21: G = __loaded[1];
+                            let __v_22: G = __loaded[2];
+                            match __v_20.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_23: G = __loaded[0];
+                                let __v_24: G = __loaded[1];
+                                let __v_25: G = __loaded[2];
+                                match __v_23.as_canonical_u64() {
+                                  0u64 => {
+                                    let __ret: [G; OUT_165] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25];
+                                    if !unconstrained { record.virt += record.function_queries[165].weight(); } record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64()));
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
   })
 }
 
-const INPUT_SIZE_173: usize = 19;
-const IN_173: usize = 19;
-const OUT_173: usize = 4;
-fn aiur_fn_173(
-  inp: [G; IN_173],
+const INPUT_SIZE_166: usize = 2;
+const IN_166: usize = 2;
+const OUT_166: usize = 10;
+fn aiur_fn_166(
+  inp: [G; IN_166],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_173], ExecError> {
+) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_19: G = __loaded[0];
-    let __v_20: G = __loaded[1];
-    let __v_21: G = __loaded[2];
-    match __v_19.as_canonical_u64() {
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1]; 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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __v_12: G = G::from_u64(1020);
+    let __v_13: G = (__v_9 - __v_12);
+    let __v_14: G = (__v_8 + __v_13);
+    let __v_15: G = (__v_7 + __v_14);
+    let __v_16: G = (__v_6 + __v_15);
+    let __v_17: G = G::from_bool((__v_16 == G::ZERO));
+    let __v_18: G = (__v_4 + __v_5);
+    let __v_19: G = (__v_3 + __v_18);
+    let __v_20: G = (__v_2 + __v_19);
+    let __v_21: G = G::from_bool((__v_20 == G::ZERO));
+    let __v_22: G = G::from_u64(1);
+    let __v_23: G = G::from_u64(1);
+    let __v_24: G = (__v_23 - __v_21);
+    let __v_25: G = (__v_17 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    match __v_26.as_canonical_u64() {
       1u64 => {
-        let __v_22: G = G::from_u64(0);
-        let __v_23: G = G::from_u64(0);
-        let __v_24: G = G::from_u64(0);
-        let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_173] = [__v_22, __v_23, __v_24, __v_25];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
-        let __v_22: G = __r_arr[0];
-        let __v_23: G = __r_arr[1];
-        let __v_24: G = __r_arr[2];
-        let __v_25: G = __r_arr[3];
-        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
-        let __v_26: G = __r_arr[0];
-        let __v_27: G = __r_arr[1];
-        let __v_28: G = __r_arr[2];
-        let __v_29: G = __r_arr[3];
-        let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-        let __v_30: G = __r_arr[0];
-        let __v_31: G = __r_arr[1];
-        let __v_32: G = (__v_26 + __v_30);
-        let __v_33: G = (__v_27 + __v_31);
-        let __ret: [G; OUT_173] = [__v_32, __v_33, __v_28, __v_29];
-        if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_166] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_11]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        let __v_28: G = __r_arr[1];
+        let __v_29: G = __r_arr[2];
+        let __v_30: G = __r_arr[3];
+        let __v_31: G = __r_arr[4];
+        let __v_32: G = __r_arr[5];
+        let __v_33: G = __r_arr[6];
+        let __v_34: G = __r_arr[7];
+        let __v_35: G = __r_arr[8];
+        let __v_36: G = __r_arr[9];
+        let __ret: [G; OUT_166] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+        if !unconstrained { record.virt += record.function_queries[166].weight(); } record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_174: usize = 44;
-const IN_174: usize = 44;
-const OUT_174: usize = 2;
-fn aiur_fn_174(
-  inp: [G; IN_174],
+const INPUT_SIZE_167: usize = 2;
+const IN_167: usize = 2;
+const OUT_167: usize = 18;
+fn aiur_fn_167(
+  inp: [G; IN_167],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_174], ExecError> {
+) -> Result<[G; OUT_167], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    let __v_37: G = inp[37];
-    let __v_38: G = inp[38];
-    let __v_39: G = inp[39];
-    let __v_40: G = inp[40];
-    let __v_41: G = inp[41];
-    let __v_42: G = inp[42];
-    let __v_43: G = inp[43];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_44: G = __loaded[0];
-    let __v_45: G = __loaded[1];
-    let __v_46: G = __loaded[2];
-    let __v_47: G = __loaded[3];
-    match __v_44.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_174] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_45.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } };
-            let __v_48: G = __r_arr[0];
-            let __v_49: G = __r_arr[1];
-            let __v_50: G = __r_arr[2];
-            let __v_51: G = __r_arr[3];
-            let __v_52: G = (__v_48 + __v_22);
-            let __v_53: G = (__v_49 + __v_23);
-            let __v_54: G = (__v_50 + __v_24);
-            let __v_55: G = (__v_51 + __v_25);
-            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } };
-            let __v_56: G = __r_arr[0];
-            let __v_57: G = __r_arr[1];
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
-            let __v_58: G = __r_arr[0];
-            let __v_59: G = __r_arr[1];
-            let __v_60: G = __r_arr[2];
-            let __v_61: G = __r_arr[3];
-            let __v_62: G = (__v_56 * __v_10);
-            let __v_63: G = G::from_u64(7);
-            let __v_64: G = (__v_57 * __v_11);
-            let __v_65: G = (__v_63 * __v_64);
-            let __v_66: G = (__v_62 + __v_65);
-            let __v_67: G = (__v_56 * __v_11);
-            let __v_68: G = (__v_57 * __v_10);
-            let __v_69: G = (__v_67 + __v_68);
-            let __v_70: G = (__v_58 + __v_66);
-            let __v_71: G = (__v_59 + __v_69);
-            let __v_72: G = (__v_56 * __v_12);
-            let __v_73: G = G::from_u64(7);
-            let __v_74: G = (__v_57 * __v_13);
-            let __v_75: G = (__v_73 * __v_74);
-            let __v_76: G = (__v_72 + __v_75);
-            let __v_77: G = (__v_56 * __v_13);
-            let __v_78: G = (__v_57 * __v_12);
-            let __v_79: G = (__v_77 + __v_78);
-            let __v_80: G = (__v_60 + __v_76);
-            let __v_81: G = (__v_61 + __v_79);
-            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
-            let __v_82: G = __r_arr[0];
-            let __v_83: G = __r_arr[1];
-            let __v_84: G = __r_arr[2];
-            let __v_85: G = __r_arr[3];
-            let __v_86: G = G::from_u64(1);
-            let __v_87: G = (__v_86 - __v_6);
-            let __v_88: G = (__v_5 + __v_87);
-            match __v_88.as_canonical_u64() {
-              0u64 => {
-                let __v_89: G = (__v_7 + __v_7);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_90: G = __r_arr[0];
-                let __v_91: G = __r_arr[1];
-                let __v_92: G = G::from_u64(1);
-                let __v_93: G = (__v_7 + __v_92);
-                let __v_94: G = (__v_7 + __v_93);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_95: G = __r_arr[0];
-                let __v_96: G = __r_arr[1];
-                let __v_97: G = G::from_u64(0);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_98: G = __r_arr[0];
-                let __v_99: G = __r_arr[1];
-                let __v_100: G = (__v_98 + __v_18);
-                let __v_101: G = (__v_99 + __v_19);
-                let __v_102: G = G::from_u64(1);
-                let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_36, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                let __v_103: G = __r_arr[0];
-                let __v_104: G = __r_arr[1];
-                let __v_105: G = (__v_103 + __v_20);
-                let __v_106: G = (__v_104 + __v_21);
-                let __v_107: G = (__v_100 - __v_90);
-                let __v_108: G = (__v_101 - __v_91);
-                let __v_109: G = (__v_105 - __v_95);
-                let __v_110: G = (__v_106 - __v_96);
-                let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
-                let __v_111: G = __r_arr[0];
-                let __v_112: G = __r_arr[1];
-                let __v_113: G = __r_arr[2];
-                let __v_114: G = __r_arr[3];
-                let __v_115: G = (__v_111 - __v_70);
-                let __v_116: G = (__v_112 - __v_71);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-                let __v_117: G = __r_arr[0];
-                let __v_118: G = __r_arr[1];
-                let __v_119: G = (__v_113 - __v_80);
-                let __v_120: G = (__v_114 - __v_81);
-                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-                let __v_121: G = __r_arr[0];
-                let __v_122: G = __r_arr[1];
-                let __ret: [G; OUT_174] = [__v_121, __v_122];
-                if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_89: G = G::from_u64(1);
-                let __v_90: G = (__v_8 - __v_89);
-                match __v_90.as_canonical_u64() {
-                  0u64 => {
-                    let __v_91: G = (__v_7 + __v_7);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                    let __v_92: G = __r_arr[0];
-                    let __v_93: G = __r_arr[1];
-                    let __v_94: G = G::from_u64(1);
-                    let __v_95: G = (__v_7 + __v_94);
-                    let __v_96: G = (__v_7 + __v_95);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                    let __v_97: G = __r_arr[0];
-                    let __v_98: G = __r_arr[1];
-                    let __v_99: G = G::from_u64(2);
-                    let __v_100: G = (__v_7 + __v_99);
-                    let __v_101: G = (__v_7 + __v_100);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                    let __v_102: G = __r_arr[0];
-                    let __v_103: G = __r_arr[1];
-                    let __v_104: G = G::from_u64(3);
-                    let __v_105: G = (__v_7 + __v_104);
-                    let __v_106: G = (__v_7 + __v_105);
-                    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_35, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-                    let __v_107: G = __r_arr[0];
-                    let __v_108: G = __r_arr[1];
-                    let __v_109: G = (__v_102 - __v_92);
-                    let __v_110: G = (__v_103 - __v_93);
-                    let __v_111: G = (__v_107 - __v_97);
-                    let __v_112: G = (__v_108 - __v_98);
-                    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } };
-                    let __v_113: G = __r_arr[0];
-                    let __v_114: G = __r_arr[1];
-                    let __v_115: G = __r_arr[2];
-                    let __v_116: G = __r_arr[3];
-                    let __v_117: G = (__v_113 - __v_70);
-                    let __v_118: G = (__v_114 - __v_71);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-                    let __v_119: G = __r_arr[0];
-                    let __v_120: G = __r_arr[1];
-                    let __v_121: G = (__v_115 - __v_80);
-                    let __v_122: G = (__v_116 - __v_81);
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-                    let __v_123: G = __r_arr[0];
-                    let __v_124: G = __r_arr[1];
-                    let __v_125: G = G::from_u64(1);
-                    let __v_126: G = (__v_5 + __v_125);
-                    let __v_127: G = G::from_u64(1);
-                    let __v_128: G = (__v_7 + __v_127);
-                    let __v_129: G = G::from_u64(1);
-                    let __v_130: G = G::from_u64(0);
-                    let __v_131: G = G::from_u64(0);
-                    let __v_132: G = G::from_u64(0);
-                    let __v_133: G = G::from_u64(0);
-                    let __v_134: G = G::from_u64(0);
-                    let __v_135: G = G::from_u64(0);
-                    let __v_136: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
-                    let __v_137: G = __r_arr[0];
-                    let __v_138: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_137, __v_138];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                  _ => {
-                    let __v_91: G = G::from_u64(1);
-                    let __v_92: G = (__v_5 + __v_91);
-                    let __v_93: G = G::from_u64(1);
-                    let __v_94: G = (__v_8 - __v_93);
-                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
-                    let __v_95: G = __r_arr[0];
-                    let __v_96: G = __r_arr[1];
-                    let __ret: [G; OUT_174] = [__v_95, __v_96];
-                    if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                    return Ok(__ret);
-                  },
-                }
-              },
-            }
-          },
-        }
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = __r_arr[8];
+    let __v_11: G = __r_arr[9];
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_10, __v_11]; 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 { let __r = record.function_queries[166].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __v_14: G = __r_arr[2];
+    let __v_15: G = __r_arr[3];
+    let __v_16: G = __r_arr[4];
+    let __v_17: G = __r_arr[5];
+    let __v_18: G = __r_arr[6];
+    let __v_19: G = __r_arr[7];
+    let __v_20: G = __r_arr[8];
+    let __v_21: G = __r_arr[9];
+    let __ret: [G; OUT_167] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+    if !unconstrained { record.virt += record.function_queries[167].weight(); } record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_168: usize = 2;
+const IN_168: usize = 2;
+const OUT_168: usize = 1;
+fn aiur_fn_168(
+  inp: [G; IN_168],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_168], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_168] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_2: G = __loaded[0];
+        let __v_3: G = __loaded[1];
+        let __v_4: G = __loaded[2];
+        match __v_2.as_canonical_u64() {
+          0u64 => {
+            let __v_5: G = G::from_u64(0);
+            let __v_6: G = G::from_u64(1);
+            let __v_7: G = (__v_1 - __v_6);
+            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_4, __v_7]; 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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_168] = [__v_9];
+            if !unconstrained { record.virt += record.function_queries[168].weight(); } record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-const INPUT_SIZE_175: usize = 28;
-const IN_175: usize = 28;
-const OUT_175: usize = 2;
-fn aiur_fn_175(
-  inp: [G; IN_175],
+const INPUT_SIZE_169: usize = 3;
+const IN_169: usize = 3;
+const OUT_169: usize = 3;
+fn aiur_fn_169(
+  inp: [G; IN_169],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_175], ExecError> {
+) -> Result<[G; OUT_169], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = G::from_u64(0);
-    let __v_29: G = G::from_u64(0);
-    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
-    let __v_30: G = __r_arr[0];
-    let __v_31: G = __r_arr[1];
-    let __v_32: G = G::from_u64(0);
-    let __v_33: G = G::from_u64(0);
-    let __v_34: G = G::from_u64(0);
-    let __v_35: G = G::from_u64(0);
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = G::from_u64(0);
-    let __v_38: G = G::from_u64(0);
-    let __v_39: G = G::from_u64(0);
-    let __v_40: G = (__v_17 - __v_15);
-    let __v_41: G = (__v_38 - __v_36);
-    let __v_42: G = G::from_u64(0);
-    let __v_43: G = (__v_40 * __v_27);
-    let __v_44: G = G::from_u64(7);
-    let __v_45: G = (__v_41 * __v_42);
-    let __v_46: G = (__v_44 * __v_45);
-    let __v_47: G = (__v_43 + __v_46);
-    let __v_48: G = (__v_40 * __v_42);
-    let __v_49: G = (__v_41 * __v_27);
-    let __v_50: G = (__v_48 + __v_49);
-    let __v_51: G = (__v_21 * __v_47);
-    let __v_52: G = G::from_u64(7);
-    let __v_53: G = (__v_22 * __v_50);
-    let __v_54: G = (__v_52 * __v_53);
-    let __v_55: G = (__v_51 + __v_54);
-    let __v_56: G = (__v_21 * __v_50);
-    let __v_57: G = (__v_22 * __v_47);
-    let __v_58: G = (__v_56 + __v_57);
-    let __v_59: G = (__v_18 - __v_16);
-    let __v_60: G = (__v_39 - __v_37);
-    let __v_61: G = G::from_u64(0);
-    let __v_62: G = (__v_59 * __v_27);
-    let __v_63: G = G::from_u64(7);
-    let __v_64: G = (__v_60 * __v_61);
-    let __v_65: G = (__v_63 * __v_64);
-    let __v_66: G = (__v_62 + __v_65);
-    let __v_67: G = (__v_59 * __v_61);
-    let __v_68: G = (__v_60 * __v_27);
-    let __v_69: G = (__v_67 + __v_68);
-    let __v_70: G = (__v_21 * __v_66);
-    let __v_71: G = G::from_u64(7);
-    let __v_72: G = (__v_22 * __v_69);
-    let __v_73: G = (__v_71 * __v_72);
-    let __v_74: G = (__v_70 + __v_73);
-    let __v_75: G = (__v_21 * __v_69);
-    let __v_76: G = (__v_22 * __v_66);
-    let __v_77: G = (__v_75 + __v_76);
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_78: G = __loaded[0];
-    let __v_79: G = __loaded[1];
-    let __v_80: G = __loaded[2];
-    let __v_81: G = __loaded[3];
-    match __v_78.as_canonical_u64() {
-      1u64 => {
-        let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_83: G = __r_arr[0];
-        let __v_84: G = __r_arr[1];
-        let __v_85: G = G::from_u64(0);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_86: G = __r_arr[0];
-        let __v_87: G = __r_arr[1];
-        let __v_88: G = (__v_83 - __v_86);
-        let __v_89: G = (__v_84 - __v_87);
-        let __v_90: G = (__v_88 + __v_55);
-        let __v_91: G = (__v_89 + __v_58);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-        let __v_92: G = __r_arr[0];
-        let __v_93: G = __r_arr[1];
-        let __v_94: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_9, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_95: G = __r_arr[0];
-        let __v_96: G = __r_arr[1];
-        let __v_97: G = G::from_u64(1);
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_8, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-        let __v_98: G = __r_arr[0];
-        let __v_99: G = __r_arr[1];
-        let __v_100: G = (__v_95 - __v_98);
-        let __v_101: G = (__v_96 - __v_99);
-        let __v_102: G = (__v_100 + __v_74);
-        let __v_103: G = (__v_101 + __v_77);
-        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-        let __v_104: G = __r_arr[0];
-        let __v_105: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_104, __v_105];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_82: G = G::from_u64(0);
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_83: G = __r_arr[0];
-        let __v_84: G = G::from_u64(0);
-        let __v_85: G = G::from_u64(1);
-        let __v_86: G = G::from_u64(0);
-        let __v_87: G = G::from_u64(0);
-        let __v_88: G = G::from_u64(0);
-        let __v_89: G = G::from_u64(0);
-        let __v_90: G = G::from_u64(0);
-        let __v_91: G = G::from_u64(0);
-        let __v_92: G = G::from_u64(0);
-        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
-        let __v_93: G = __r_arr[0];
-        let __v_94: G = __r_arr[1];
-        let __ret: [G; OUT_175] = [__v_93, __v_94];
-        if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_78.as_canonical_u64()));
-      },
-    }
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1]; 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 { let __r = record.function_queries[165].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __v_11: G = __r_arr[8];
+    let __v_12: G = __r_arr[9];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) };
+    let __v_13: G = __b1_out[0];
+    let __v_14: G = __b1_out[1];
+    let __v_15: G = __b1_out[2];
+    let __v_16: G = __b1_out[3];
+    let __v_17: G = __b1_out[4];
+    let __v_18: G = __b1_out[5];
+    let __v_19: G = __b1_out[6];
+    let __v_20: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) };
+    let __v_21: G = __b1_out[0];
+    let __v_22: G = __b1_out[1];
+    let __v_23: G = __b1_out[2];
+    let __v_24: G = __b1_out[3];
+    let __v_25: G = __b1_out[4];
+    let __v_26: G = __b1_out[5];
+    let __v_27: G = __b1_out[6];
+    let __v_28: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) };
+    let __v_29: G = __b1_out[0];
+    let __v_30: G = __b1_out[1];
+    let __v_31: G = __b1_out[2];
+    let __v_32: G = __b1_out[3];
+    let __v_33: G = __b1_out[4];
+    let __v_34: G = __b1_out[5];
+    let __v_35: G = __b1_out[6];
+    let __v_36: G = __b1_out[7];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) };
+    let __v_37: G = __b1_out[0];
+    let __v_38: G = __b1_out[1];
+    let __v_39: G = __b1_out[2];
+    let __v_40: G = __b1_out[3];
+    let __v_41: G = __b1_out[4];
+    let __v_42: G = __b1_out[5];
+    let __v_43: G = __b1_out[6];
+    let __v_44: G = __b1_out[7];
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_51, __v_2]; 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 { let __r = record.function_queries[168].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+    let __ret: [G; OUT_169] = [__v_52, __v_11, __v_12];
+    if !unconstrained { record.virt += record.function_queries[169].weight(); } record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_176: usize = 8;
-const IN_176: usize = 8;
-const OUT_176: usize = 1;
-fn aiur_fn_176(
-  inp: [G; IN_176],
+const INPUT_SIZE_170: usize = 9;
+const IN_170: usize = 9;
+const OUT_170: usize = 1;
+fn aiur_fn_170(
+  inp: [G; IN_170],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_176], ExecError> {
+) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -16372,304 +16190,197 @@ fn aiur_fn_176(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __v_8: G = G::from_u64(0);
+    let __v_8: G = inp[8];
+    let __v_9: G = G::from_u64(1);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_12]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __ret: [G; OUT_170] = [__v_13];
+    if !unconstrained { record.virt += record.function_queries[170].weight(); } record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_171: usize = 2;
+const IN_171: usize = 2;
+const OUT_171: usize = 1;
+fn aiur_fn_171(
+  inp: [G; IN_171],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_171], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_1, __v_4]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_0, __v_5]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+    let __ret: [G; OUT_171] = [__v_6];
+    if !unconstrained { record.virt += record.function_queries[171].weight(); } record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_172: usize = 1;
+const IN_172: usize = 1;
+const OUT_172: usize = 1;
+fn aiur_fn_172(
+  inp: [G; IN_172],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_172], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(109);
+    let __v_3: G = G::from_u64(0);
+    let __v_4: G = G::from_u64(117);
+    let __v_5: G = G::from_u64(0);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(116);
     let __v_9: G = G::from_u64(0);
-    let __v_10: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(105);
     let __v_11: G = G::from_u64(0);
-    let __v_12: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(45);
     let __v_13: G = G::from_u64(0);
-    let __v_14: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(115);
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(116);
     let __v_17: G = G::from_u64(0);
-    let __v_18: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(97);
     let __v_19: G = G::from_u64(0);
-    let __v_20: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(114);
     let __v_21: G = G::from_u64(0);
-    let __v_22: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(107);
     let __v_23: G = G::from_u64(0);
-    let __v_24: G = G::from_u64(1);
-    let __v_25: G = G::from_u64(1);
-    let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_176] = [__v_34];
-    if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_24: G = G::from_u64(47);
+    let __v_25: G = G::from_u64(0);
+    let __v_26: G = G::from_u64(118);
+    let __v_27: G = G::from_u64(0);
+    let __v_28: G = G::from_u64(48);
+    let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_172] = [__v_42];
+    if !unconstrained { record.virt += record.function_queries[172].weight(); } record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 5;
-const IN_177: usize = 5;
-const OUT_177: usize = 2;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_173: usize = 2;
+const IN_173: usize = 2;
+const OUT_173: usize = 1;
+fn aiur_fn_173(
+  inp: [G; IN_173],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], ExecError> {
+) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_5: G = __loaded[0];
-    let __v_6: G = __loaded[1];
-    let __v_7: G = __loaded[2];
-    let __v_8: G = __loaded[3];
-    match __v_5.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    match __v_2.as_canonical_u64() {
       1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_177] = [__v_9, __v_10];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_173] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_9: G = (__v_3 * __v_6);
-        let __v_10: G = G::from_u64(7);
-        let __v_11: G = (__v_4 * __v_7);
-        let __v_12: G = (__v_10 * __v_11);
-        let __v_13: G = (__v_9 + __v_12);
-        let __v_14: G = (__v_3 * __v_7);
-        let __v_15: G = (__v_4 * __v_6);
-        let __v_16: G = (__v_14 + __v_15);
-        let __v_17: G = (__v_3 * __v_1);
-        let __v_18: G = G::from_u64(7);
-        let __v_19: G = (__v_4 * __v_2);
-        let __v_20: G = (__v_18 * __v_19);
-        let __v_21: G = (__v_17 + __v_20);
-        let __v_22: G = (__v_3 * __v_2);
-        let __v_23: G = (__v_4 * __v_1);
-        let __v_24: G = (__v_22 + __v_23);
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
-        let __v_25: G = __r_arr[0];
-        let __v_26: G = __r_arr[1];
-        let __v_27: G = (__v_13 + __v_25);
-        let __v_28: G = (__v_16 + __v_26);
-        let __ret: [G; OUT_177] = [__v_27, __v_28];
-        if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_11, __v_1]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __ret: [G; OUT_173] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[173].weight(); } record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_178: usize = 1;
-const IN_178: usize = 1;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+const INPUT_SIZE_174: usize = 2;
+const IN_174: usize = 2;
+const OUT_174: usize = 1;
+fn aiur_fn_174(
+  inp: [G; IN_174],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_174] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       1u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      2u64 => {
-        let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      3u64 => {
-        let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      4u64 => {
-        let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      5u64 => {
-        let __v_1: G = G::from_u64(4);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      6u64 => {
-        let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      7u64 => {
-        let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      8u64 => {
-        let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      9u64 => {
-        let __v_1: G = G::from_u64(8);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      10u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      11u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      12u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      13u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      14u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      15u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      16u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      17u64 => {
-        let __v_1: G = G::from_u64(16);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __v_1: G = G::from_u64(32);
-        let __ret: [G; OUT_178] = [__v_1];
-        if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_179: usize = 4;
-const IN_179: usize = 4;
-const OUT_179: usize = 2;
-fn aiur_fn_179(
-  inp: [G; IN_179],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_179], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    match __v_2.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = G::from_u64(1);
-        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = G::from_u64(1);
-        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_179] = [__v_6, __v_9];
-        if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_174] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[174].weight(); } record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      1u64 => {
-        match __v_0.as_canonical_u64() {
-          0u64 => {
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = G::from_u64(1);
-            let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_179] = [__v_6, __v_9];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_4: G = __r_arr[0];
-            let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_6: G = __r_arr[0];
-            let __v_7: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_179] = [__v_6, __v_8];
-            if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_180: usize = 20;
-const IN_180: usize = 20;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_175: usize = 9;
+const IN_175: usize = 9;
+const OUT_175: usize = 9;
+fn aiur_fn_175(
+  inp: [G; IN_175],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_180], ExecError> {
+) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -16679,156 +16390,2097 @@ fn aiur_fn_180(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __v_10: G = inp[10];
-    let __v_11: G = inp[11];
-    let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_20: G = __loaded[0];
-    let __v_21: G = __loaded[1];
-    let __v_22: G = __loaded[2];
-    let __v_23: G = __loaded[3];
-    let __v_24: G = __loaded[4];
-    let __v_25: G = __loaded[5];
-    let __v_26: G = __loaded[6];
-    let __v_27: G = __loaded[7];
-    match __v_20.as_canonical_u64() {
-      1u64 => {
-        let __v_28: G = G::from_u64(1);
-        let __ret: [G; OUT_180] = [__v_28];
-        if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        match __v_21.as_canonical_u64() {
-          _ => {
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } };
-            let __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_30: G = __r_arr[0];
-            let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_32: G = __r_arr[0];
-            let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_34: G = __r_arr[0];
-            let __v_35: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_37: G = __r_arr[0];
-            let __v_38: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_39: G = __r_arr[0];
-            let __v_40: G = G::from_u64(1);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_41: G = __r_arr[0];
-            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-            let __v_42: G = __r_arr[0];
-            let __v_43: G = __r_arr[1];
-            let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() {
-  0u64 => {
-    let __v_44: G = G::from_u64(1);
-    let __v_45: G = G::from_u64(1);
-    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_47: G = G::from_u64(1);
-    let __v_48: G = G::from_u64(1);
-    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_46, __v_49];
-  },
-  1u64 => {
-    match __v_6.as_canonical_u64() {
-      0u64 => {
-        let __v_44: G = G::from_u64(1);
-        let __v_45: G = G::from_u64(1);
-        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __v_47: G = G::from_u64(1);
-        let __v_48: G = G::from_u64(1);
-        let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        break '__mc_0 [__v_46, __v_49];
-      },
-      1u64 => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_44: G = __r_arr[0];
-        let __v_45: G = G::from_u64(0);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_46: G = __r_arr[0];
-        let __v_47: G = G::from_u64(1);
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_44, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-        let __v_48: G = __r_arr[0];
-        break '__mc_0 [__v_46, __v_48];
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-      },
-    }
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
-  },
-}
- };
-            let __v_44: G = __mc_out___mc_0[0];
-            let __v_45: G = __mc_out___mc_0[1];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-            let __v_46: G = __r_arr[0];
-            let __v_47: G = __r_arr[1];
-            let __v_48: G = G::from_u64(1);
-            let __v_49: G = G::from_u64(0);
-            let __v_50: G = (__v_46 - __v_48);
-            let __v_51: G = (__v_47 - __v_49);
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-            let __v_52: G = __r_arr[0];
-            let __v_53: G = g_inverse_value(__v_52);
-            let __v_54: G = (__v_52 * __v_53);
-            let __v_55: G = G::from_u64(1);
-            let __v_56: G = (__v_54 - __v_55);
-            let __v_57: G = (__v_52 * __v_56);
-            let __v_58: G = G::from_u64(0);
-            if (__v_57 != __v_58) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
-            }
-            let __v_59: G = (__v_53 * __v_56);
-            let __v_60: G = G::from_u64(0);
-            if (__v_59 != __v_60) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
-            }
-            let __v_61: G = G::from_u64(1);
-            let __v_62: G = G::from_u64(0);
-            let __v_63: G = (__v_18 - __v_61);
-            let __v_64: G = (__v_19 - __v_62);
-            let __v_65: G = (__v_63 * __v_63);
-            let __v_66: G = G::from_u64(7);
-            let __v_67: G = (__v_64 * __v_64);
-            let __v_68: G = (__v_66 * __v_67);
-            let __v_69: G = (__v_65 - __v_68);
-            let __v_70: G = g_inverse_value(__v_69);
-            let __v_71: G = (__v_69 * __v_70);
-            let __v_72: G = G::from_u64(1);
-            let __v_73: G = (__v_71 - __v_72);
-            let __v_74: G = (__v_69 * __v_73);
-            let __v_75: G = G::from_u64(0);
-            if (__v_74 != __v_75) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
-            }
-            let __v_76: G = (__v_70 * __v_73);
-            let __v_77: G = G::from_u64(0);
-            if (__v_76 != __v_77) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
-            }
-            let __v_78: G = (__v_63 * __v_70);
-            let __v_79: G = G::from_u64(0);
-            let __v_80: G = (__v_79 - __v_64);
-            let __v_81: G = (__v_80 * __v_70);
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_6, __v_7]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_9]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_2, __v_10]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_11]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_0, __v_12]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(109);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(117);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(108);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(116);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(105);
+    let __v_24: G = G::from_u64(0);
+    let __v_25: G = G::from_u64(45);
+    let __v_26: G = G::from_u64(0);
+    let __v_27: G = G::from_u64(115);
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(116);
+    let __v_30: G = G::from_u64(0);
+    let __v_31: G = G::from_u64(97);
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(114);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(107);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(47);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(118);
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = G::from_u64(48);
+    let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_56: G = G::from_u64(1);
+    let __v_57: G = G::from_u64(1);
+    let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_55, __v_58]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __v_62: G = __r_arr[3];
+    let __v_63: G = __r_arr[4];
+    let __v_64: G = __r_arr[5];
+    let __v_65: G = __r_arr[6];
+    let __v_66: G = __r_arr[7];
+    let __v_67: G = __r_arr[8];
+    let __v_68: G = __r_arr[9];
+    let __v_69: G = __r_arr[10];
+    let __v_70: G = __r_arr[11];
+    let __v_71: G = __r_arr[12];
+    let __v_72: G = __r_arr[13];
+    let __v_73: G = __r_arr[14];
+    let __v_74: G = __r_arr[15];
+    let __v_75: G = __r_arr[16];
+    let __v_76: G = __r_arr[17];
+    let __v_77: G = G::from_u64(1);
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_75, __v_81]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+    let __v_83: G = G::from_u64(1);
+    let __v_84: G = G::from_u64(1);
+    let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_82, __v_85]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_86: G = __r_arr[0];
+    let __v_87: G = __r_arr[1];
+    let __v_88: G = __r_arr[2];
+    let __v_89: G = __r_arr[3];
+    let __v_90: G = __r_arr[4];
+    let __v_91: G = __r_arr[5];
+    let __v_92: G = __r_arr[6];
+    let __v_93: G = __r_arr[7];
+    let __v_94: G = __r_arr[8];
+    let __v_95: G = __r_arr[9];
+    let __v_96: G = __r_arr[10];
+    let __v_97: G = __r_arr[11];
+    let __v_98: G = __r_arr[12];
+    let __v_99: G = __r_arr[13];
+    let __v_100: G = __r_arr[14];
+    let __v_101: G = __r_arr[15];
+    let __v_102: G = __r_arr[16];
+    let __v_103: G = __r_arr[17];
+    let __v_104: G = G::from_u64(1);
+    let __v_105: G = G::from_u64(1);
+    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_107: G = __r_arr[0];
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_108: G = __r_arr[0];
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_102, __v_108]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_109: G = __r_arr[0];
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_109, __v_4]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_110: G = __r_arr[0];
+    let __v_111: G = G::from_u64(1);
+    let __v_112: G = G::from_u64(1);
+    let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_8, __v_113]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_114: G = __r_arr[0];
+    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_110, __v_114]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_115: G = __r_arr[0];
+    let __v_116: G = G::from_u64(1);
+    let __v_117: G = G::from_u64(1);
+    let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_115, __v_118]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __v_121: G = __r_arr[2];
+    let __v_122: G = __r_arr[3];
+    let __v_123: G = __r_arr[4];
+    let __v_124: G = __r_arr[5];
+    let __v_125: G = __r_arr[6];
+    let __v_126: G = __r_arr[7];
+    let __v_127: G = __r_arr[8];
+    let __v_128: G = __r_arr[9];
+    let __v_129: G = __r_arr[10];
+    let __v_130: G = __r_arr[11];
+    let __v_131: G = __r_arr[12];
+    let __v_132: G = __r_arr[13];
+    let __v_133: G = __r_arr[14];
+    let __v_134: G = __r_arr[15];
+    let __v_135: G = __r_arr[16];
+    let __v_136: G = __r_arr[17];
+    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_135, __v_5]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_137: G = __r_arr[0];
+    let __v_138: G = G::from_u64(1);
+    let __v_139: G = G::from_u64(1);
+    let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_137, __v_140]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __v_143: G = __r_arr[2];
+    let __v_144: G = __r_arr[3];
+    let __v_145: G = __r_arr[4];
+    let __v_146: G = __r_arr[5];
+    let __v_147: G = __r_arr[6];
+    let __v_148: G = __r_arr[7];
+    let __v_149: G = __r_arr[8];
+    let __v_150: G = __r_arr[9];
+    let __v_151: G = __r_arr[10];
+    let __v_152: G = __r_arr[11];
+    let __v_153: G = __r_arr[12];
+    let __v_154: G = __r_arr[13];
+    let __v_155: G = __r_arr[14];
+    let __v_156: G = __r_arr[15];
+    let __v_157: G = __r_arr[16];
+    let __v_158: G = __r_arr[17];
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_60);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_61);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_62);
+    let __v_165: G = G::from_u64(4294967296);
+    let __v_166: G = (__v_165 * __v_63);
+    let __v_167: G = G::from_u64(1099511627776);
+    let __v_168: G = (__v_167 * __v_64);
+    let __v_169: G = G::from_u64(281474976710656);
+    let __v_170: G = (__v_169 * __v_65);
+    let __v_171: G = G::from_u64(72057594037927936);
+    let __v_172: G = (__v_171 * __v_66);
+    let __v_173: G = (__v_170 + __v_172);
+    let __v_174: G = (__v_168 + __v_173);
+    let __v_175: G = (__v_166 + __v_174);
+    let __v_176: G = (__v_164 + __v_175);
+    let __v_177: G = (__v_162 + __v_176);
+    let __v_178: G = (__v_160 + __v_177);
+    let __v_179: G = (__v_59 + __v_178);
+    let __v_180: G = G::from_u64(256);
+    let __v_181: G = (__v_180 * __v_68);
+    let __v_182: G = G::from_u64(65536);
+    let __v_183: G = (__v_182 * __v_69);
+    let __v_184: G = G::from_u64(16777216);
+    let __v_185: G = (__v_184 * __v_70);
+    let __v_186: G = G::from_u64(4294967296);
+    let __v_187: G = (__v_186 * __v_71);
+    let __v_188: G = G::from_u64(1099511627776);
+    let __v_189: G = (__v_188 * __v_72);
+    let __v_190: G = G::from_u64(281474976710656);
+    let __v_191: G = (__v_190 * __v_73);
+    let __v_192: G = G::from_u64(72057594037927936);
+    let __v_193: G = (__v_192 * __v_74);
+    let __v_194: G = (__v_191 + __v_193);
+    let __v_195: G = (__v_189 + __v_194);
+    let __v_196: G = (__v_187 + __v_195);
+    let __v_197: G = (__v_185 + __v_196);
+    let __v_198: G = (__v_183 + __v_197);
+    let __v_199: G = (__v_181 + __v_198);
+    let __v_200: G = (__v_67 + __v_199);
+    let __v_201: G = G::from_u64(256);
+    let __v_202: G = (__v_201 * __v_87);
+    let __v_203: G = G::from_u64(65536);
+    let __v_204: G = (__v_203 * __v_88);
+    let __v_205: G = G::from_u64(16777216);
+    let __v_206: G = (__v_205 * __v_89);
+    let __v_207: G = G::from_u64(4294967296);
+    let __v_208: G = (__v_207 * __v_90);
+    let __v_209: G = G::from_u64(1099511627776);
+    let __v_210: G = (__v_209 * __v_91);
+    let __v_211: G = G::from_u64(281474976710656);
+    let __v_212: G = (__v_211 * __v_92);
+    let __v_213: G = G::from_u64(72057594037927936);
+    let __v_214: G = (__v_213 * __v_93);
+    let __v_215: G = (__v_212 + __v_214);
+    let __v_216: G = (__v_210 + __v_215);
+    let __v_217: G = (__v_208 + __v_216);
+    let __v_218: G = (__v_206 + __v_217);
+    let __v_219: G = (__v_204 + __v_218);
+    let __v_220: G = (__v_202 + __v_219);
+    let __v_221: G = (__v_86 + __v_220);
+    let __v_222: G = G::from_u64(256);
+    let __v_223: G = (__v_222 * __v_95);
+    let __v_224: G = G::from_u64(65536);
+    let __v_225: G = (__v_224 * __v_96);
+    let __v_226: G = G::from_u64(16777216);
+    let __v_227: G = (__v_226 * __v_97);
+    let __v_228: G = G::from_u64(4294967296);
+    let __v_229: G = (__v_228 * __v_98);
+    let __v_230: G = G::from_u64(1099511627776);
+    let __v_231: G = (__v_230 * __v_99);
+    let __v_232: G = G::from_u64(281474976710656);
+    let __v_233: G = (__v_232 * __v_100);
+    let __v_234: G = G::from_u64(72057594037927936);
+    let __v_235: G = (__v_234 * __v_101);
+    let __v_236: G = (__v_233 + __v_235);
+    let __v_237: G = (__v_231 + __v_236);
+    let __v_238: G = (__v_229 + __v_237);
+    let __v_239: G = (__v_227 + __v_238);
+    let __v_240: G = (__v_225 + __v_239);
+    let __v_241: G = (__v_223 + __v_240);
+    let __v_242: G = (__v_94 + __v_241);
+    let __v_243: G = G::from_u64(256);
+    let __v_244: G = (__v_243 * __v_120);
+    let __v_245: G = G::from_u64(65536);
+    let __v_246: G = (__v_245 * __v_121);
+    let __v_247: G = G::from_u64(16777216);
+    let __v_248: G = (__v_247 * __v_122);
+    let __v_249: G = G::from_u64(4294967296);
+    let __v_250: G = (__v_249 * __v_123);
+    let __v_251: G = G::from_u64(1099511627776);
+    let __v_252: G = (__v_251 * __v_124);
+    let __v_253: G = G::from_u64(281474976710656);
+    let __v_254: G = (__v_253 * __v_125);
+    let __v_255: G = G::from_u64(72057594037927936);
+    let __v_256: G = (__v_255 * __v_126);
+    let __v_257: G = (__v_254 + __v_256);
+    let __v_258: G = (__v_252 + __v_257);
+    let __v_259: G = (__v_250 + __v_258);
+    let __v_260: G = (__v_248 + __v_259);
+    let __v_261: G = (__v_246 + __v_260);
+    let __v_262: G = (__v_244 + __v_261);
+    let __v_263: G = (__v_119 + __v_262);
+    let __v_264: G = G::from_u64(256);
+    let __v_265: G = (__v_264 * __v_128);
+    let __v_266: G = G::from_u64(65536);
+    let __v_267: G = (__v_266 * __v_129);
+    let __v_268: G = G::from_u64(16777216);
+    let __v_269: G = (__v_268 * __v_130);
+    let __v_270: G = G::from_u64(4294967296);
+    let __v_271: G = (__v_270 * __v_131);
+    let __v_272: G = G::from_u64(1099511627776);
+    let __v_273: G = (__v_272 * __v_132);
+    let __v_274: G = G::from_u64(281474976710656);
+    let __v_275: G = (__v_274 * __v_133);
+    let __v_276: G = G::from_u64(72057594037927936);
+    let __v_277: G = (__v_276 * __v_134);
+    let __v_278: G = (__v_275 + __v_277);
+    let __v_279: G = (__v_273 + __v_278);
+    let __v_280: G = (__v_271 + __v_279);
+    let __v_281: G = (__v_269 + __v_280);
+    let __v_282: G = (__v_267 + __v_281);
+    let __v_283: G = (__v_265 + __v_282);
+    let __v_284: G = (__v_127 + __v_283);
+    let __v_285: G = G::from_u64(256);
+    let __v_286: G = (__v_285 * __v_142);
+    let __v_287: G = G::from_u64(65536);
+    let __v_288: G = (__v_287 * __v_143);
+    let __v_289: G = G::from_u64(16777216);
+    let __v_290: G = (__v_289 * __v_144);
+    let __v_291: G = G::from_u64(4294967296);
+    let __v_292: G = (__v_291 * __v_145);
+    let __v_293: G = G::from_u64(1099511627776);
+    let __v_294: G = (__v_293 * __v_146);
+    let __v_295: G = G::from_u64(281474976710656);
+    let __v_296: G = (__v_295 * __v_147);
+    let __v_297: G = G::from_u64(72057594037927936);
+    let __v_298: G = (__v_297 * __v_148);
+    let __v_299: G = (__v_296 + __v_298);
+    let __v_300: G = (__v_294 + __v_299);
+    let __v_301: G = (__v_292 + __v_300);
+    let __v_302: G = (__v_290 + __v_301);
+    let __v_303: G = (__v_288 + __v_302);
+    let __v_304: G = (__v_286 + __v_303);
+    let __v_305: G = (__v_141 + __v_304);
+    let __v_306: G = G::from_u64(256);
+    let __v_307: G = (__v_306 * __v_150);
+    let __v_308: G = G::from_u64(65536);
+    let __v_309: G = (__v_308 * __v_151);
+    let __v_310: G = G::from_u64(16777216);
+    let __v_311: G = (__v_310 * __v_152);
+    let __v_312: G = G::from_u64(4294967296);
+    let __v_313: G = (__v_312 * __v_153);
+    let __v_314: G = G::from_u64(1099511627776);
+    let __v_315: G = (__v_314 * __v_154);
+    let __v_316: G = G::from_u64(281474976710656);
+    let __v_317: G = (__v_316 * __v_155);
+    let __v_318: G = G::from_u64(72057594037927936);
+    let __v_319: G = (__v_318 * __v_156);
+    let __v_320: G = (__v_317 + __v_319);
+    let __v_321: G = (__v_315 + __v_320);
+    let __v_322: G = (__v_313 + __v_321);
+    let __v_323: G = (__v_311 + __v_322);
+    let __v_324: G = (__v_309 + __v_323);
+    let __v_325: G = (__v_307 + __v_324);
+    let __v_326: G = (__v_149 + __v_325);
+    let __ret: [G; OUT_175] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157];
+    if !unconstrained { record.virt += record.function_queries[175].weight(); } record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_176: usize = 3;
+const IN_176: usize = 3;
+const OUT_176: usize = 2;
+fn aiur_fn_176(
+  inp: [G; IN_176],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_176], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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_176] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_3: G = (__v_0 * __v_0);
+        let __v_4: G = G::from_u64(7);
+        let __v_5: G = (__v_1 * __v_1);
+        let __v_6: G = (__v_4 * __v_5);
+        let __v_7: G = (__v_3 + __v_6);
+        let __v_8: G = (__v_0 * __v_1);
+        let __v_9: G = (__v_1 * __v_0);
+        let __v_10: G = (__v_8 + __v_9);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_2 - __v_11);
+        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_7, __v_10, __v_12]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_176] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[176].weight(); } record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_177: usize = 1;
+const IN_177: usize = 1;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_177] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      32u64 => {
+        let __v_1: G = G::from_u64(1753635133440165772);
+        let __ret: [G; OUT_177] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(1);
+        let __v_2: G = (__v_0 + __v_1);
+        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = (__v_3 * __v_3);
+        let __ret: [G; OUT_177] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[177].weight(); } record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_178: usize = 3;
+const IN_178: usize = 3;
+const OUT_178: usize = 2;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __ret: [G; OUT_178] = [__v_7, __v_8];
+    if !unconstrained { record.virt += record.function_queries[178].weight(); } record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_179: usize = 1;
+const IN_179: usize = 1;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_179] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(2);
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_0 - __v_2);
+        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_3]; 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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = (__v_1 * __v_4);
+        let __ret: [G; OUT_179] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[179].weight(); } record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_180: usize = 3;
+const IN_180: usize = 3;
+const OUT_180: usize = 8;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = G::from_u64(0);
+    let __v_7: G = (__v_3 - __v_5);
+    let __v_8: G = (__v_4 - __v_6);
+    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+    let __v_10: G = g_inverse_value(__v_9);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = G::from_u64(1);
+    let __v_13: G = (__v_11 - __v_12);
+    let __v_14: G = (__v_9 * __v_13);
+    let __v_15: G = G::from_u64(0);
+    if (__v_14 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __v_16: G = (__v_10 * __v_13);
+    let __v_17: G = G::from_u64(0);
+    if (__v_16 != __v_17) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: None });
+    }
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = (__v_0 - __v_18);
+    let __v_21: G = (__v_1 - __v_19);
+    let __v_22: G = (__v_20 * __v_20);
+    let __v_23: G = G::from_u64(7);
+    let __v_24: G = (__v_21 * __v_21);
+    let __v_25: G = (__v_23 * __v_24);
+    let __v_26: G = (__v_22 - __v_25);
+    let __v_27: G = g_inverse_value(__v_26);
+    let __v_28: G = (__v_26 * __v_27);
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = (__v_28 - __v_29);
+    let __v_31: G = (__v_26 * __v_30);
+    let __v_32: G = G::from_u64(0);
+    if (__v_31 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: None });
+    }
+    let __v_33: G = (__v_27 * __v_30);
+    let __v_34: G = G::from_u64(0);
+    if (__v_33 != __v_34) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: None });
+    }
+    let __v_35: G = (__v_20 * __v_27);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = (__v_36 - __v_21);
+    let __v_38: G = (__v_37 * __v_27);
+    let __v_39: G = (__v_7 * __v_35);
+    let __v_40: G = G::from_u64(7);
+    let __v_41: G = (__v_8 * __v_38);
+    let __v_42: G = (__v_40 * __v_41);
+    let __v_43: G = (__v_39 + __v_42);
+    let __v_44: G = (__v_7 * __v_38);
+    let __v_45: G = (__v_8 * __v_35);
+    let __v_46: G = (__v_44 + __v_45);
+    let __v_47: G = G::from_u64(0);
+    let __v_48: G = (__v_0 - __v_10);
+    let __v_49: G = (__v_1 - __v_47);
+    let __v_50: G = (__v_48 * __v_48);
+    let __v_51: G = G::from_u64(7);
+    let __v_52: G = (__v_49 * __v_49);
+    let __v_53: G = (__v_51 * __v_52);
+    let __v_54: G = (__v_50 - __v_53);
+    let __v_55: G = g_inverse_value(__v_54);
+    let __v_56: G = (__v_54 * __v_55);
+    let __v_57: G = G::from_u64(1);
+    let __v_58: G = (__v_56 - __v_57);
+    let __v_59: G = (__v_54 * __v_58);
+    let __v_60: G = G::from_u64(0);
+    if (__v_59 != __v_60) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+    }
+    let __v_61: G = (__v_55 * __v_58);
+    let __v_62: G = G::from_u64(0);
+    if (__v_61 != __v_62) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64(), msg: None });
+    }
+    let __v_63: G = (__v_48 * __v_55);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = (__v_64 - __v_49);
+    let __v_66: G = (__v_65 * __v_55);
+    let __v_67: G = (__v_7 * __v_63);
+    let __v_68: G = G::from_u64(7);
+    let __v_69: G = (__v_8 * __v_66);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_67 + __v_70);
+    let __v_72: G = (__v_7 * __v_66);
+    let __v_73: G = (__v_8 * __v_63);
+    let __v_74: G = (__v_72 + __v_73);
+    let __v_75: G = G::from_u64(0);
+    let __v_76: G = (__v_0 - __v_10);
+    let __v_77: G = (__v_1 - __v_75);
+    let __v_78: G = (__v_7 * __v_7);
+    let __v_79: G = G::from_u64(7);
+    let __v_80: G = (__v_8 * __v_8);
+    let __v_81: G = (__v_79 * __v_80);
+    let __v_82: G = (__v_78 - __v_81);
+    let __v_83: G = g_inverse_value(__v_82);
+    let __v_84: G = (__v_82 * __v_83);
+    let __v_85: G = G::from_u64(1);
+    let __v_86: G = (__v_84 - __v_85);
+    let __v_87: G = (__v_82 * __v_86);
+    let __v_88: G = G::from_u64(0);
+    if (__v_87 != __v_88) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_88.as_canonical_u64(), msg: None });
+    }
+    let __v_89: G = (__v_83 * __v_86);
+    let __v_90: G = G::from_u64(0);
+    if (__v_89 != __v_90) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64(), msg: None });
+    }
+    let __v_91: G = (__v_7 * __v_83);
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = (__v_92 - __v_8);
+    let __v_94: G = (__v_93 * __v_83);
+    let __ret: [G; OUT_180] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94];
+    if !unconstrained { record.virt += record.function_queries[180].weight(); } record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_181: usize = 24;
+const IN_181: usize = 24;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+        let __v_25: G = G::from_bool((__v_24 == G::ZERO));
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_22]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+        if (__v_27 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_23]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+        if (__v_28 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_19]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+        if (__v_29 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_4]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+        let __v_31: G = G::from_u64(1);
+        if (__v_30 != __v_31) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None });
+        }
+        let __v_32: G = G::from_u64(1);
+        let __ret: [G; OUT_181] = [__v_32];
+        if !unconstrained { record.virt += record.function_queries[181].weight(); } record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_182: usize = 6;
+const IN_182: usize = 6;
+const OUT_182: usize = 2;
+fn aiur_fn_182(
+  inp: [G; IN_182],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_182], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 = (__v_0 * __v_2);
+    let __v_7: G = G::from_u64(7);
+    let __v_8: G = (__v_1 * __v_3);
+    let __v_9: G = (__v_7 * __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_0 * __v_3);
+    let __v_12: G = (__v_1 * __v_2);
+    let __v_13: G = (__v_11 + __v_12);
+    let __v_14: G = (__v_10 + __v_4);
+    let __v_15: G = (__v_13 + __v_5);
+    let __ret: [G; OUT_182] = [__v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[182].weight(); } record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_183: usize = 4;
+const IN_183: usize = 4;
+const OUT_183: usize = 2;
+fn aiur_fn_183(
+  inp: [G; IN_183],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_183], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(0);
+    let __v_5: G = G::from_u64(1);
+    let __v_6: G = (__v_2 * __v_4);
+    let __v_7: G = G::from_u64(7);
+    let __v_8: G = (__v_3 * __v_5);
+    let __v_9: G = (__v_7 * __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_2 * __v_5);
+    let __v_12: G = (__v_3 * __v_4);
+    let __v_13: G = (__v_11 + __v_12);
+    let __v_14: G = (__v_0 + __v_10);
+    let __v_15: G = (__v_1 + __v_13);
+    let __ret: [G; OUT_183] = [__v_14, __v_15];
+    if !unconstrained { record.virt += record.function_queries[183].weight(); } record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    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],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_184], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_184] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __v_9: G = G::from_u64(0);
+            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_2, __v_3, __v_6, __v_7]; 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 { let __r = record.function_queries[183].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+            let __v_11: G = __r_arr[1];
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_8]; 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 { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+            let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_184] = [__v_13];
+            if !unconstrained { record.virt += record.function_queries[184].weight(); } record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_185: usize = 15;
+const IN_185: usize = 15;
+const OUT_185: usize = 2;
+fn aiur_fn_185(
+  inp: [G; IN_185],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_185], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_1]; 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 { let __r = record.function_queries[249].replay_at(__i); record.virt += __r; } 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_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];
+    match __v_15.as_canonical_u64() {
+      0u64 => {
+        let __v_19: G = G::from_u64(0);
+        let __ret: [G; OUT_185] = [__v_16, __v_19];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_19: G = (__v_16 + __v_17);
+        let __v_20: G = (__v_16 + __v_19);
+        match __v_20.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_4, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_5, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          2u64 => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          3u64 => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_3, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          4u64 => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_6, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_7, __v_18]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+            let __v_22: G = __r_arr[1];
+            let __ret: [G; OUT_185] = [__v_21, __v_22];
+            if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_16]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __ret: [G; OUT_185] = [__v_19, __v_20];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __ret: [G; OUT_185] = [__v_9, __v_10];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __ret: [G; OUT_185] = [__v_11, __v_12];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __ret: [G; OUT_185] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 + __v_21);
+        let __v_24: G = (__v_20 + __v_22);
+        let __ret: [G; OUT_185] = [__v_23, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 - __v_21);
+        let __v_24: G = (__v_20 - __v_22);
+        let __ret: [G; OUT_185] = [__v_23, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+        let __v_22: G = __r_arr[1];
+        let __v_23: G = (__v_19 * __v_21);
+        let __v_24: G = G::from_u64(7);
+        let __v_25: G = (__v_20 * __v_22);
+        let __v_26: G = (__v_24 * __v_25);
+        let __v_27: G = (__v_23 + __v_26);
+        let __v_28: G = (__v_19 * __v_22);
+        let __v_29: G = (__v_20 * __v_21);
+        let __v_30: G = (__v_28 + __v_29);
+        let __ret: [G; OUT_185] = [__v_27, __v_30];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_16, __v_2, __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[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_19: G = __r_arr[0];
+        let __v_20: G = __r_arr[1];
+        let __v_21: G = G::from_u64(0);
+        let __v_22: G = (__v_21 - __v_19);
+        let __v_23: G = G::from_u64(0);
+        let __v_24: G = (__v_23 - __v_20);
+        let __ret: [G; OUT_185] = [__v_22, __v_24];
+        if !unconstrained { record.virt += record.function_queries[185].weight(); } record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_186: usize = 19;
+const IN_186: usize = 19;
+const OUT_186: usize = 2;
+fn aiur_fn_186(
+  inp: [G; IN_186],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_186], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_19: G = __loaded[0];
+    let __v_20: G = __loaded[1];
+    let __v_21: G = __loaded[2];
+    match __v_19.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_186] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __ret: [G; OUT_186] = [__v_26, __v_27];
+        if !unconstrained { record.virt += record.function_queries[186].weight(); } record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_187: usize = 8;
+const IN_187: usize = 8;
+const OUT_187: usize = 4;
+fn aiur_fn_187(
+  inp: [G; IN_187],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_187], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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 = (__v_0 * __v_4);
+    let __v_9: G = G::from_u64(7);
+    let __v_10: G = (__v_1 * __v_5);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = (__v_8 + __v_11);
+    let __v_13: G = (__v_0 * __v_5);
+    let __v_14: G = (__v_1 * __v_4);
+    let __v_15: G = (__v_13 + __v_14);
+    let __v_16: G = G::from_u64(7);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = (__v_2 * __v_6);
+    let __v_19: G = G::from_u64(7);
+    let __v_20: G = (__v_3 * __v_7);
+    let __v_21: G = (__v_19 * __v_20);
+    let __v_22: G = (__v_18 + __v_21);
+    let __v_23: G = (__v_2 * __v_7);
+    let __v_24: G = (__v_3 * __v_6);
+    let __v_25: G = (__v_23 + __v_24);
+    let __v_26: G = (__v_16 * __v_22);
+    let __v_27: G = G::from_u64(7);
+    let __v_28: G = (__v_17 * __v_25);
+    let __v_29: G = (__v_27 * __v_28);
+    let __v_30: G = (__v_26 + __v_29);
+    let __v_31: G = (__v_16 * __v_25);
+    let __v_32: G = (__v_17 * __v_22);
+    let __v_33: G = (__v_31 + __v_32);
+    let __v_34: G = (__v_0 * __v_6);
+    let __v_35: G = G::from_u64(7);
+    let __v_36: G = (__v_1 * __v_7);
+    let __v_37: G = (__v_35 * __v_36);
+    let __v_38: G = (__v_34 + __v_37);
+    let __v_39: G = (__v_0 * __v_7);
+    let __v_40: G = (__v_1 * __v_6);
+    let __v_41: G = (__v_39 + __v_40);
+    let __v_42: G = (__v_2 * __v_4);
+    let __v_43: G = G::from_u64(7);
+    let __v_44: G = (__v_3 * __v_5);
+    let __v_45: G = (__v_43 * __v_44);
+    let __v_46: G = (__v_42 + __v_45);
+    let __v_47: G = (__v_2 * __v_5);
+    let __v_48: G = (__v_3 * __v_4);
+    let __v_49: G = (__v_47 + __v_48);
+    let __v_50: G = (__v_12 + __v_30);
+    let __v_51: G = (__v_15 + __v_33);
+    let __v_52: G = (__v_38 + __v_46);
+    let __v_53: G = (__v_41 + __v_49);
+    let __ret: [G; OUT_187] = [__v_50, __v_51, __v_52, __v_53];
+    if !unconstrained { record.virt += record.function_queries[187].weight(); } record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_188: usize = 19;
+const IN_188: usize = 19;
+const OUT_188: usize = 4;
+fn aiur_fn_188(
+  inp: [G; IN_188],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_188], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_19: G = __loaded[0];
+    let __v_20: G = __loaded[1];
+    let __v_21: G = __loaded[2];
+    match __v_19.as_canonical_u64() {
+      1u64 => {
+        let __v_22: G = G::from_u64(0);
+        let __v_23: G = G::from_u64(0);
+        let __v_24: G = G::from_u64(0);
+        let __v_25: G = G::from_u64(0);
+        let __ret: [G; OUT_188] = [__v_22, __v_23, __v_24, __v_25];
+        if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
+        let __v_23: G = __r_arr[1];
+        let __v_24: G = __r_arr[2];
+        let __v_25: G = __r_arr[3];
+        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+        let __v_27: G = __r_arr[1];
+        let __v_28: G = __r_arr[2];
+        let __v_29: G = __r_arr[3];
+        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+        let __v_31: G = __r_arr[1];
+        let __v_32: G = (__v_26 + __v_30);
+        let __v_33: G = (__v_27 + __v_31);
+        let __ret: [G; OUT_188] = [__v_32, __v_33, __v_28, __v_29];
+        if !unconstrained { record.virt += record.function_queries[188].weight(); } record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_189: usize = 44;
+const IN_189: usize = 44;
+const OUT_189: usize = 2;
+fn aiur_fn_189(
+  inp: [G; IN_189],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_189], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    let __v_38: G = inp[38];
+    let __v_39: G = inp[39];
+    let __v_40: G = inp[40];
+    let __v_41: G = inp[41];
+    let __v_42: G = inp[42];
+    let __v_43: G = inp[43];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    let __v_47: G = __loaded[3];
+    match __v_44.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_189] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_45.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[188].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+            let __v_49: G = __r_arr[1];
+            let __v_50: G = __r_arr[2];
+            let __v_51: G = __r_arr[3];
+            let __v_52: G = (__v_48 + __v_22);
+            let __v_53: G = (__v_49 + __v_23);
+            let __v_54: G = (__v_50 + __v_24);
+            let __v_55: G = (__v_51 + __v_25);
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[185].replay_at(__i); record.virt += __r; } 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_56: G = __r_arr[0];
+            let __v_57: G = __r_arr[1];
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_58: G = __r_arr[0];
+            let __v_59: G = __r_arr[1];
+            let __v_60: G = __r_arr[2];
+            let __v_61: G = __r_arr[3];
+            let __v_62: G = (__v_56 * __v_10);
+            let __v_63: G = G::from_u64(7);
+            let __v_64: G = (__v_57 * __v_11);
+            let __v_65: G = (__v_63 * __v_64);
+            let __v_66: G = (__v_62 + __v_65);
+            let __v_67: G = (__v_56 * __v_11);
+            let __v_68: G = (__v_57 * __v_10);
+            let __v_69: G = (__v_67 + __v_68);
+            let __v_70: G = (__v_58 + __v_66);
+            let __v_71: G = (__v_59 + __v_69);
+            let __v_72: G = (__v_56 * __v_12);
+            let __v_73: G = G::from_u64(7);
+            let __v_74: G = (__v_57 * __v_13);
+            let __v_75: G = (__v_73 * __v_74);
+            let __v_76: G = (__v_72 + __v_75);
+            let __v_77: G = (__v_56 * __v_13);
+            let __v_78: G = (__v_57 * __v_12);
+            let __v_79: G = (__v_77 + __v_78);
+            let __v_80: G = (__v_60 + __v_76);
+            let __v_81: G = (__v_61 + __v_79);
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+            let __v_83: G = __r_arr[1];
+            let __v_84: G = __r_arr[2];
+            let __v_85: G = __r_arr[3];
+            let __v_86: G = G::from_u64(1);
+            let __v_87: G = (__v_86 - __v_6);
+            let __v_88: G = (__v_5 + __v_87);
+            match __v_88.as_canonical_u64() {
+              0u64 => {
+                let __v_89: G = (__v_7 + __v_7);
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_89]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_90: G = __r_arr[0];
+                let __v_91: G = __r_arr[1];
+                let __v_92: G = G::from_u64(1);
+                let __v_93: G = (__v_7 + __v_92);
+                let __v_94: G = (__v_7 + __v_93);
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_94]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+                let __v_96: G = __r_arr[1];
+                let __v_97: G = G::from_u64(0);
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_36, __v_97]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+                let __v_99: G = __r_arr[1];
+                let __v_100: G = (__v_98 + __v_18);
+                let __v_101: G = (__v_99 + __v_19);
+                let __v_102: G = G::from_u64(1);
+                let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_36, __v_102]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_103: G = __r_arr[0];
+                let __v_104: G = __r_arr[1];
+                let __v_105: G = (__v_103 + __v_20);
+                let __v_106: G = (__v_104 + __v_21);
+                let __v_107: G = (__v_100 - __v_90);
+                let __v_108: G = (__v_101 - __v_91);
+                let __v_109: G = (__v_105 - __v_95);
+                let __v_110: G = (__v_106 - __v_96);
+                let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_111: G = __r_arr[0];
+                let __v_112: G = __r_arr[1];
+                let __v_113: G = __r_arr[2];
+                let __v_114: G = __r_arr[3];
+                let __v_115: G = (__v_111 - __v_70);
+                let __v_116: G = (__v_112 - __v_71);
+                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_117: G = __r_arr[0];
+                let __v_118: G = __r_arr[1];
+                let __v_119: G = (__v_113 - __v_80);
+                let __v_120: G = (__v_114 - __v_81);
+                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_121: G = __r_arr[0];
+                let __v_122: G = __r_arr[1];
+                let __ret: [G; OUT_189] = [__v_121, __v_122];
+                if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_89: G = G::from_u64(1);
+                let __v_90: G = (__v_8 - __v_89);
+                match __v_90.as_canonical_u64() {
+                  0u64 => {
+                    let __v_91: G = (__v_7 + __v_7);
+                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_91]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_92: G = __r_arr[0];
+                    let __v_93: G = __r_arr[1];
+                    let __v_94: G = G::from_u64(1);
+                    let __v_95: G = (__v_7 + __v_94);
+                    let __v_96: G = (__v_7 + __v_95);
+                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_96]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_97: G = __r_arr[0];
+                    let __v_98: G = __r_arr[1];
+                    let __v_99: G = G::from_u64(2);
+                    let __v_100: G = (__v_7 + __v_99);
+                    let __v_101: G = (__v_7 + __v_100);
+                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_101]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_102: G = __r_arr[0];
+                    let __v_103: G = __r_arr[1];
+                    let __v_104: G = G::from_u64(3);
+                    let __v_105: G = (__v_7 + __v_104);
+                    let __v_106: G = (__v_7 + __v_105);
+                    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_35, __v_106]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_107: G = __r_arr[0];
+                    let __v_108: G = __r_arr[1];
+                    let __v_109: G = (__v_102 - __v_92);
+                    let __v_110: G = (__v_103 - __v_93);
+                    let __v_111: G = (__v_107 - __v_97);
+                    let __v_112: G = (__v_108 - __v_98);
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; 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 { let __r = record.function_queries[187].replay_at(__i); record.virt += __r; } 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_113: G = __r_arr[0];
+                    let __v_114: G = __r_arr[1];
+                    let __v_115: G = __r_arr[2];
+                    let __v_116: G = __r_arr[3];
+                    let __v_117: G = (__v_113 - __v_70);
+                    let __v_118: G = (__v_114 - __v_71);
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_119: G = __r_arr[0];
+                    let __v_120: G = __r_arr[1];
+                    let __v_121: G = (__v_115 - __v_80);
+                    let __v_122: G = (__v_116 - __v_81);
+                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+                    let __v_124: G = __r_arr[1];
+                    let __v_125: G = G::from_u64(1);
+                    let __v_126: G = (__v_5 + __v_125);
+                    let __v_127: G = G::from_u64(1);
+                    let __v_128: G = (__v_7 + __v_127);
+                    let __v_129: G = G::from_u64(1);
+                    let __v_130: G = G::from_u64(0);
+                    let __v_131: G = G::from_u64(0);
+                    let __v_132: G = G::from_u64(0);
+                    let __v_133: G = G::from_u64(0);
+                    let __v_134: G = G::from_u64(0);
+                    let __v_135: G = G::from_u64(0);
+                    let __v_136: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_137: G = __r_arr[0];
+                    let __v_138: G = __r_arr[1];
+                    let __ret: [G; OUT_189] = [__v_137, __v_138];
+                    if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_91: G = G::from_u64(1);
+                    let __v_92: G = (__v_5 + __v_91);
+                    let __v_93: G = G::from_u64(1);
+                    let __v_94: G = (__v_8 - __v_93);
+                    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+                    let __v_96: G = __r_arr[1];
+                    let __ret: [G; OUT_189] = [__v_95, __v_96];
+                    if !unconstrained { record.virt += record.function_queries[189].weight(); } record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_190: usize = 28;
+const IN_190: usize = 28;
+const OUT_190: usize = 2;
+fn aiur_fn_190(
+  inp: [G; IN_190],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_190], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = G::from_u64(0);
+    let __v_29: G = G::from_u64(0);
+    let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __v_32: G = G::from_u64(0);
+    let __v_33: G = G::from_u64(0);
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = G::from_u64(0);
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = G::from_u64(0);
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = (__v_17 - __v_15);
+    let __v_41: G = (__v_38 - __v_36);
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = (__v_40 * __v_27);
+    let __v_44: G = G::from_u64(7);
+    let __v_45: G = (__v_41 * __v_42);
+    let __v_46: G = (__v_44 * __v_45);
+    let __v_47: G = (__v_43 + __v_46);
+    let __v_48: G = (__v_40 * __v_42);
+    let __v_49: G = (__v_41 * __v_27);
+    let __v_50: G = (__v_48 + __v_49);
+    let __v_51: G = (__v_21 * __v_47);
+    let __v_52: G = G::from_u64(7);
+    let __v_53: G = (__v_22 * __v_50);
+    let __v_54: G = (__v_52 * __v_53);
+    let __v_55: G = (__v_51 + __v_54);
+    let __v_56: G = (__v_21 * __v_50);
+    let __v_57: G = (__v_22 * __v_47);
+    let __v_58: G = (__v_56 + __v_57);
+    let __v_59: G = (__v_18 - __v_16);
+    let __v_60: G = (__v_39 - __v_37);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = (__v_59 * __v_27);
+    let __v_63: G = G::from_u64(7);
+    let __v_64: G = (__v_60 * __v_61);
+    let __v_65: G = (__v_63 * __v_64);
+    let __v_66: G = (__v_62 + __v_65);
+    let __v_67: G = (__v_59 * __v_61);
+    let __v_68: G = (__v_60 * __v_27);
+    let __v_69: G = (__v_67 + __v_68);
+    let __v_70: G = (__v_21 * __v_66);
+    let __v_71: G = G::from_u64(7);
+    let __v_72: G = (__v_22 * __v_69);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_70 + __v_73);
+    let __v_75: G = (__v_21 * __v_69);
+    let __v_76: G = (__v_22 * __v_66);
+    let __v_77: G = (__v_75 + __v_76);
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_78: G = __loaded[0];
+    let __v_79: G = __loaded[1];
+    let __v_80: G = __loaded[2];
+    let __v_81: G = __loaded[3];
+    match __v_78.as_canonical_u64() {
+      1u64 => {
+        let __v_82: G = G::from_u64(0);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_82]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+        let __v_84: G = __r_arr[1];
+        let __v_85: G = G::from_u64(0);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_85]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_86: G = __r_arr[0];
+        let __v_87: G = __r_arr[1];
+        let __v_88: G = (__v_83 - __v_86);
+        let __v_89: G = (__v_84 - __v_87);
+        let __v_90: G = (__v_88 + __v_55);
+        let __v_91: G = (__v_89 + __v_58);
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_92: G = __r_arr[0];
+        let __v_93: G = __r_arr[1];
+        let __v_94: G = G::from_u64(1);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_9, __v_94]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_95: G = __r_arr[0];
+        let __v_96: G = __r_arr[1];
+        let __v_97: G = G::from_u64(1);
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_8, __v_97]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_98: G = __r_arr[0];
+        let __v_99: G = __r_arr[1];
+        let __v_100: G = (__v_95 - __v_98);
+        let __v_101: G = (__v_96 - __v_99);
+        let __v_102: G = (__v_100 + __v_74);
+        let __v_103: G = (__v_101 + __v_77);
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_104: G = __r_arr[0];
+        let __v_105: G = __r_arr[1];
+        let __ret: [G; OUT_190] = [__v_104, __v_105];
+        if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_82: G = G::from_u64(0);
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+        let __v_84: G = G::from_u64(0);
+        let __v_85: G = G::from_u64(1);
+        let __v_86: G = G::from_u64(0);
+        let __v_87: G = G::from_u64(0);
+        let __v_88: G = G::from_u64(0);
+        let __v_89: G = G::from_u64(0);
+        let __v_90: G = G::from_u64(0);
+        let __v_91: G = G::from_u64(0);
+        let __v_92: G = G::from_u64(0);
+        let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_93: G = __r_arr[0];
+        let __v_94: G = __r_arr[1];
+        let __ret: [G; OUT_190] = [__v_93, __v_94];
+        if !unconstrained { record.virt += record.function_queries[190].weight(); } record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_78.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_191: usize = 8;
+const IN_191: usize = 8;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_191], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = G::from_u64(0);
+    let __v_10: G = G::from_u64(0);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(0);
+    let __v_14: G = G::from_u64(0);
+    let __v_15: G = G::from_u64(0);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(0);
+    let __v_18: G = G::from_u64(0);
+    let __v_19: G = G::from_u64(0);
+    let __v_20: G = G::from_u64(0);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(0);
+    let __v_23: G = G::from_u64(0);
+    let __v_24: G = G::from_u64(1);
+    let __v_25: G = G::from_u64(1);
+    let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_191] = [__v_34];
+    if !unconstrained { record.virt += record.function_queries[191].weight(); } record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_192: usize = 5;
+const IN_192: usize = 5;
+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_192], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_5: G = __loaded[0];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    let __v_8: G = __loaded[3];
+    match __v_5.as_canonical_u64() {
+      1u64 => {
+        let __v_9: G = G::from_u64(0);
+        let __v_10: G = G::from_u64(0);
+        let __ret: [G; OUT_192] = [__v_9, __v_10];
+        if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_9: G = (__v_3 * __v_6);
+        let __v_10: G = G::from_u64(7);
+        let __v_11: G = (__v_4 * __v_7);
+        let __v_12: G = (__v_10 * __v_11);
+        let __v_13: G = (__v_9 + __v_12);
+        let __v_14: G = (__v_3 * __v_7);
+        let __v_15: G = (__v_4 * __v_6);
+        let __v_16: G = (__v_14 + __v_15);
+        let __v_17: G = (__v_3 * __v_1);
+        let __v_18: G = G::from_u64(7);
+        let __v_19: G = (__v_4 * __v_2);
+        let __v_20: G = (__v_18 * __v_19);
+        let __v_21: G = (__v_17 + __v_20);
+        let __v_22: G = (__v_3 * __v_2);
+        let __v_23: G = (__v_4 * __v_1);
+        let __v_24: G = (__v_22 + __v_23);
+        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_1, __v_2, __v_21, __v_24]; 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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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_25: G = __r_arr[0];
+        let __v_26: G = __r_arr[1];
+        let __v_27: G = (__v_13 + __v_25);
+        let __v_28: G = (__v_16 + __v_26);
+        let __ret: [G; OUT_192] = [__v_27, __v_28];
+        if !unconstrained { record.virt += record.function_queries[192].weight(); } record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_193: usize = 1;
+const IN_193: usize = 1;
+const OUT_193: usize = 1;
+fn aiur_fn_193(
+  inp: [G; IN_193],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_193], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    match __v_0.as_canonical_u64() {
+      0u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __v_1: G = G::from_u64(1);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      3u64 => {
+        let __v_1: G = G::from_u64(2);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      4u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      5u64 => {
+        let __v_1: G = G::from_u64(4);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      6u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      7u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      8u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_1: G = G::from_u64(8);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      10u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      11u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      12u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      13u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      14u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      15u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      16u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      17u64 => {
+        let __v_1: G = G::from_u64(16);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __v_1: G = G::from_u64(32);
+        let __ret: [G; OUT_193] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[193].weight(); } record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_194: usize = 4;
+const IN_194: usize = 4;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_194], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    match __v_2.as_canonical_u64() {
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_194] = [__v_6, __v_9];
+        if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        match __v_0.as_canonical_u64() {
+          0u64 => {
+            let __v_4: G = G::from_u64(1);
+            let __v_5: G = G::from_u64(1);
+            let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_7: G = G::from_u64(1);
+            let __v_8: G = G::from_u64(1);
+            let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_194] = [__v_6, __v_9];
+            if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_1, __v_3]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+            let __v_5: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_5]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = G::from_u64(1);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_7]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_194] = [__v_6, __v_8];
+            if !unconstrained { record.virt += record.function_queries[194].weight(); } record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_195: usize = 20;
+const IN_195: usize = 20;
+const OUT_195: usize = 1;
+fn aiur_fn_195(
+  inp: [G; IN_195],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_195], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_20: G = __loaded[0];
+    let __v_21: G = __loaded[1];
+    let __v_22: G = __loaded[2];
+    let __v_23: G = __loaded[3];
+    let __v_24: G = __loaded[4];
+    let __v_25: G = __loaded[5];
+    let __v_26: G = __loaded[6];
+    let __v_27: G = __loaded[7];
+    match __v_20.as_canonical_u64() {
+      1u64 => {
+        let __v_28: G = G::from_u64(1);
+        let __ret: [G; OUT_195] = [__v_28];
+        if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_21.as_canonical_u64() {
+          _ => {
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_2, __v_9]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_28: G = __r_arr[0];
+            let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_24]; 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 { let __r = record.function_queries[193].replay_at(__i); record.virt += __r; } 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_29: G = __r_arr[0];
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_3, __v_9]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+            let __v_31: G = __r_arr[1];
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_4, __v_9]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_32: G = __r_arr[0];
+            let __v_33: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_32, __v_33]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+            let __v_35: G = G::from_u64(1);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_32, __v_35]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_36: G = __r_arr[0];
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_5, __v_9]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+            let __v_38: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_37, __v_38]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+            let __v_40: G = G::from_u64(1);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_37, __v_40]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_1, __v_9]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+            let __v_43: G = __r_arr[1];
+            let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() {
+  0u64 => {
+    let __v_44: G = G::from_u64(1);
+    let __v_45: G = G::from_u64(1);
+    let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_46, __v_49];
+  },
+  1u64 => {
+    match __v_6.as_canonical_u64() {
+      0u64 => {
+        let __v_44: G = G::from_u64(1);
+        let __v_45: G = G::from_u64(1);
+        let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __v_47: G = G::from_u64(1);
+        let __v_48: G = G::from_u64(1);
+        let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        break '__mc_0 [__v_46, __v_49];
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_7, __v_43]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = G::from_u64(0);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44, __v_45]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __v_47: G = G::from_u64(1);
+        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_44, __v_47]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
+        break '__mc_0 [__v_46, __v_48];
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+      },
+    }
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64()));
+  },
+}
+ };
+            let __v_44: G = __mc_out___mc_0[0];
+            let __v_45: G = __mc_out___mc_0[1];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_18, __v_19, __v_28]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+            let __v_47: G = __r_arr[1];
+            let __v_48: G = G::from_u64(1);
+            let __v_49: G = G::from_u64(0);
+            let __v_50: G = (__v_46 - __v_48);
+            let __v_51: G = (__v_47 - __v_49);
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+            let __v_53: G = g_inverse_value(__v_52);
+            let __v_54: G = (__v_52 * __v_53);
+            let __v_55: G = G::from_u64(1);
+            let __v_56: G = (__v_54 - __v_55);
+            let __v_57: G = (__v_52 * __v_56);
+            let __v_58: G = G::from_u64(0);
+            if (__v_57 != __v_58) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None });
+            }
+            let __v_59: G = (__v_53 * __v_56);
+            let __v_60: G = G::from_u64(0);
+            if (__v_59 != __v_60) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64(), msg: None });
+            }
+            let __v_61: G = G::from_u64(1);
+            let __v_62: G = G::from_u64(0);
+            let __v_63: G = (__v_18 - __v_61);
+            let __v_64: G = (__v_19 - __v_62);
+            let __v_65: G = (__v_63 * __v_63);
+            let __v_66: G = G::from_u64(7);
+            let __v_67: G = (__v_64 * __v_64);
+            let __v_68: G = (__v_66 * __v_67);
+            let __v_69: G = (__v_65 - __v_68);
+            let __v_70: G = g_inverse_value(__v_69);
+            let __v_71: G = (__v_69 * __v_70);
+            let __v_72: G = G::from_u64(1);
+            let __v_73: G = (__v_71 - __v_72);
+            let __v_74: G = (__v_69 * __v_73);
+            let __v_75: G = G::from_u64(0);
+            if (__v_74 != __v_75) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+            }
+            let __v_76: G = (__v_70 * __v_73);
+            let __v_77: G = G::from_u64(0);
+            if (__v_76 != __v_77) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64(), msg: None });
+            }
+            let __v_78: G = (__v_63 * __v_70);
+            let __v_79: G = G::from_u64(0);
+            let __v_80: G = (__v_79 - __v_64);
+            let __v_81: G = (__v_80 * __v_70);
             let __v_82: G = (__v_50 * __v_78);
             let __v_83: G = G::from_u64(7);
             let __v_84: G = (__v_51 * __v_81);
@@ -16854,287 +18506,3412 @@ fn aiur_fn_180(
             if (__v_102 != __v_103) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_102.as_canonical_u64(), rhs: __v_103.as_canonical_u64(), msg: None });
             }
-            let __v_104: G = (__v_98 * __v_101);
-            let __v_105: G = G::from_u64(0);
-            if (__v_104 != __v_105) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
+            let __v_104: G = (__v_98 * __v_101);
+            let __v_105: G = G::from_u64(0);
+            if (__v_104 != __v_105) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_105.as_canonical_u64(), msg: None });
+            }
+            let __v_106: G = (__v_91 * __v_98);
+            let __v_107: G = G::from_u64(0);
+            let __v_108: G = (__v_107 - __v_92);
+            let __v_109: G = (__v_108 * __v_98);
+            let __v_110: G = (__v_50 * __v_106);
+            let __v_111: G = G::from_u64(7);
+            let __v_112: G = (__v_51 * __v_109);
+            let __v_113: G = (__v_111 * __v_112);
+            let __v_114: G = (__v_110 + __v_113);
+            let __v_115: G = (__v_50 * __v_109);
+            let __v_116: G = (__v_51 * __v_106);
+            let __v_117: G = (__v_115 + __v_116);
+            let __v_118: G = G::from_u64(0);
+            let __v_119: G = (__v_18 - __v_53);
+            let __v_120: G = (__v_19 - __v_118);
+            let __v_121: G = (__v_50 * __v_50);
+            let __v_122: G = G::from_u64(7);
+            let __v_123: G = (__v_51 * __v_51);
+            let __v_124: G = (__v_122 * __v_123);
+            let __v_125: G = (__v_121 - __v_124);
+            let __v_126: G = g_inverse_value(__v_125);
+            let __v_127: G = (__v_125 * __v_126);
+            let __v_128: G = G::from_u64(1);
+            let __v_129: G = (__v_127 - __v_128);
+            let __v_130: G = (__v_125 * __v_129);
+            let __v_131: G = G::from_u64(0);
+            if (__v_130 != __v_131) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+            }
+            let __v_132: G = (__v_126 * __v_129);
+            let __v_133: G = G::from_u64(0);
+            if (__v_132 != __v_133) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_133.as_canonical_u64(), msg: None });
+            }
+            let __v_134: G = (__v_50 * __v_126);
+            let __v_135: G = G::from_u64(0);
+            let __v_136: G = (__v_135 - __v_51);
+            let __v_137: G = (__v_136 * __v_126);
+            let __v_138: G = G::from_u64(0);
+            let __v_139: G = G::from_u64(0);
+            let __v_140: G = G::from_u64(0);
+            let __v_141: G = G::from_u64(0);
+            let __v_142: G = G::from_u64(0);
+            let __v_143: G = G::from_u64(0);
+            let __v_144: G = G::from_u64(0);
+            let __v_145: G = G::from_u64(0);
+            let __v_146: G = G::from_u64(0);
+            let __v_147: G = G::from_u64(0);
+            let __v_148: G = G::from_u64(0);
+            let __v_149: G = G::from_u64(0);
+            let __v_150: G = G::from_u64(0);
+            let __v_151: G = G::from_u64(0);
+            let __v_152: G = G::from_u64(0);
+            let __v_153: G = G::from_u64(0);
+            let __v_154: G = G::from_u64(1);
+            let __v_155: G = G::from_u64(1);
+            let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_28]; 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 { let __r = record.function_queries[179].replay_at(__i); record.virt += __r; } 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_165: G = __r_arr[0];
+            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_28]; 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 { let __r = record.function_queries[177].replay_at(__i); record.virt += __r; } 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_166: G = __r_arr[0];
+            let __v_167: G = (__v_165 * __v_166);
+            let __v_168: G = g_inverse_value(__v_167);
+            let __v_169: G = (__v_167 * __v_168);
+            let __v_170: G = G::from_u64(1);
+            let __v_171: G = (__v_169 - __v_170);
+            let __v_172: G = (__v_167 * __v_171);
+            let __v_173: G = G::from_u64(0);
+            if (__v_172 != __v_173) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: None });
+            }
+            let __v_174: G = (__v_168 * __v_171);
+            let __v_175: G = G::from_u64(0);
+            if (__v_174 != __v_175) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_175.as_canonical_u64(), msg: None });
+            }
+            let __v_176: G = G::from_u64(0);
+            let __v_177: G = G::from_u64(0);
+            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; 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 { let __r = record.function_queries[186].replay_at(__i); record.virt += __r; } 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_178: G = __r_arr[0];
+            let __v_179: G = __r_arr[1];
+            let __v_180: G = G::from_u64(0);
+            let __v_181: G = G::from_u64(0);
+            let __v_182: G = G::from_u64(0);
+            let __v_183: G = G::from_u64(0);
+            let __v_184: G = G::from_u64(0);
+            let __v_185: G = G::from_u64(0);
+            let __v_186: G = G::from_u64(0);
+            let __v_187: G = G::from_u64(0);
+            let __v_188: G = (__v_30 - __v_10);
+            let __v_189: G = (__v_186 - __v_184);
+            let __v_190: G = G::from_u64(0);
+            let __v_191: G = (__v_188 * __v_168);
+            let __v_192: G = G::from_u64(7);
+            let __v_193: G = (__v_189 * __v_190);
+            let __v_194: G = (__v_192 * __v_193);
+            let __v_195: G = (__v_191 + __v_194);
+            let __v_196: G = (__v_188 * __v_190);
+            let __v_197: G = (__v_189 * __v_168);
+            let __v_198: G = (__v_196 + __v_197);
+            let __v_199: G = (__v_114 * __v_195);
+            let __v_200: G = G::from_u64(7);
+            let __v_201: G = (__v_117 * __v_198);
+            let __v_202: G = (__v_200 * __v_201);
+            let __v_203: G = (__v_199 + __v_202);
+            let __v_204: G = (__v_114 * __v_198);
+            let __v_205: G = (__v_117 * __v_195);
+            let __v_206: G = (__v_204 + __v_205);
+            let __v_207: G = (__v_31 - __v_11);
+            let __v_208: G = (__v_187 - __v_185);
+            let __v_209: G = G::from_u64(0);
+            let __v_210: G = (__v_207 * __v_168);
+            let __v_211: G = G::from_u64(7);
+            let __v_212: G = (__v_208 * __v_209);
+            let __v_213: G = (__v_211 * __v_212);
+            let __v_214: G = (__v_210 + __v_213);
+            let __v_215: G = (__v_207 * __v_209);
+            let __v_216: G = (__v_208 * __v_168);
+            let __v_217: G = (__v_215 + __v_216);
+            let __v_218: G = (__v_114 * __v_214);
+            let __v_219: G = G::from_u64(7);
+            let __v_220: G = (__v_117 * __v_217);
+            let __v_221: G = (__v_219 * __v_220);
+            let __v_222: G = (__v_218 + __v_221);
+            let __v_223: G = (__v_114 * __v_217);
+            let __v_224: G = (__v_117 * __v_214);
+            let __v_225: G = (__v_223 + __v_224);
+            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; 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: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+            let __v_226: G = __loaded[0];
+            let __v_227: G = __loaded[1];
+            let __v_228: G = __loaded[2];
+            let __v_229: G = __loaded[3];
+            let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() {
+  1u64 => {
+    let __v_230: G = G::from_u64(0);
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_230]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_231: G = __r_arr[0];
+    let __v_232: G = __r_arr[1];
+    let __v_233: G = G::from_u64(0);
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_39, __v_233]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_234: G = __r_arr[0];
+    let __v_235: G = __r_arr[1];
+    let __v_236: G = (__v_231 - __v_234);
+    let __v_237: G = (__v_232 - __v_235);
+    let __v_238: G = (__v_236 + __v_203);
+    let __v_239: G = (__v_237 + __v_206);
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_240: G = __r_arr[0];
+    let __v_241: G = __r_arr[1];
+    let __v_242: G = G::from_u64(1);
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_41, __v_242]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_243: G = __r_arr[0];
+    let __v_244: G = __r_arr[1];
+    let __v_245: G = G::from_u64(1);
+    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_39, __v_245]; 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 { let __r = record.function_queries[251].replay_at(__i); record.virt += __r; } 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_246: G = __r_arr[0];
+    let __v_247: G = __r_arr[1];
+    let __v_248: G = (__v_243 - __v_246);
+    let __v_249: G = (__v_244 - __v_247);
+    let __v_250: G = (__v_248 + __v_222);
+    let __v_251: G = (__v_249 + __v_225);
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; 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 { let __r = record.function_queries[182].replay_at(__i); record.virt += __r; } 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_252: G = __r_arr[0];
+    let __v_253: G = __r_arr[1];
+    break '__mc_1 [__v_252, __v_253];
+  },
+  0u64 => {
+    let __v_230: G = G::from_u64(0);
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_25]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_231: G = __r_arr[0];
+    let __v_232: G = G::from_u64(0);
+    let __v_233: G = G::from_u64(1);
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(0);
+    let __v_237: G = G::from_u64(0);
+    let __v_238: G = G::from_u64(0);
+    let __v_239: G = G::from_u64(0);
+    let __v_240: G = G::from_u64(0);
+    let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; 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 { let __r = record.function_queries[189].replay_at(__i); record.virt += __r; } 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_241: G = __r_arr[0];
+    let __v_242: G = __r_arr[1];
+    break '__mc_1 [__v_241, __v_242];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_226.as_canonical_u64()));
+  },
+}
+ };
+            let __v_230: G = __mc_out___mc_1[0];
+            let __v_231: G = __mc_out___mc_1[1];
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_8, __v_9]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_232: G = __r_arr[0];
+            let __v_233: G = G::from_u64(0);
+            let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_232, __v_233]; 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 { let __r = record.function_queries[242].replay_at(__i); record.virt += __r; } 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_234: G = __r_arr[0];
+            let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_234]; 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 { let __r = record.function_queries[184].replay_at(__i); record.virt += __r; } 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_235: G = __r_arr[0];
+            let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_18, __v_19, __v_28]; 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 { let __r = record.function_queries[176].replay_at(__i); record.virt += __r; } 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_236: G = __r_arr[0];
+            let __v_237: G = __r_arr[1];
+            let __v_238: G = G::from_u64(1);
+            let __v_239: G = G::from_u64(0);
+            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_235, __v_236, __v_237, __v_238, __v_239]; 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 { let __r = record.function_queries[192].replay_at(__i); record.virt += __r; } 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_240: G = __r_arr[0];
+            let __v_241: G = __r_arr[1];
+            let __v_242: G = (__v_230 * __v_134);
+            let __v_243: G = G::from_u64(7);
+            let __v_244: G = (__v_231 * __v_137);
+            let __v_245: G = (__v_243 * __v_244);
+            let __v_246: G = (__v_242 + __v_245);
+            let __v_247: G = (__v_230 * __v_137);
+            let __v_248: G = (__v_231 * __v_134);
+            let __v_249: G = (__v_247 + __v_248);
+            let __v_250: G = G::from_u64(32);
+            let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) };
+            let __v_252: G = G::from_u64(1);
+            if (__v_251 != __v_252) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
+            }
+            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_235]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_253: G = __r_arr[0];
+            let __v_254: G = (__v_253 - __v_29);
+            let __v_255: G = G::from_bool((__v_254 == G::ZERO));
+            let __v_256: G = G::from_u64(1);
+            if (__v_255 != __v_256) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
+            }
+            let __v_257: G = (__v_246 - __v_240);
+            let __v_258: G = G::from_bool((__v_257 == G::ZERO));
+            let __v_259: G = (__v_249 - __v_241);
+            let __v_260: G = G::from_bool((__v_259 == G::ZERO));
+            let __v_261: G = (__v_258 * __v_260);
+            let __v_262: G = G::from_u64(1);
+            if (__v_261 != __v_262) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_262.as_canonical_u64(), msg: None });
+            }
+            let __v_263: G = G::from_u64(1);
+            let __v_264: G = (__v_9 + __v_263);
+            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_265: G = __r_arr[0];
+            let __ret: [G; OUT_195] = [__v_265];
+            if !unconstrained { record.virt += record.function_queries[195].weight(); } record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_196: usize = 3;
+const IN_196: usize = 3;
+const OUT_196: usize = 2;
+fn aiur_fn_196(
+  inp: [G; IN_196],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_196], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __v_13: G = G::from_u64(0);
+        let __v_14: G = G::from_u64(0);
+        let __ret: [G; OUT_196] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_13: G = G::from_u64(256);
+        let __v_14: G = (__v_13 * __v_5);
+        let __v_15: G = G::from_u64(65536);
+        let __v_16: G = (__v_15 * __v_6);
+        let __v_17: G = G::from_u64(16777216);
+        let __v_18: G = (__v_17 * __v_7);
+        let __v_19: G = G::from_u64(4294967296);
+        let __v_20: G = (__v_19 * __v_8);
+        let __v_21: G = G::from_u64(1099511627776);
+        let __v_22: G = (__v_21 * __v_9);
+        let __v_23: G = G::from_u64(281474976710656);
+        let __v_24: G = (__v_23 * __v_10);
+        let __v_25: G = G::from_u64(72057594037927936);
+        let __v_26: G = (__v_25 * __v_11);
+        let __v_27: G = (__v_24 + __v_26);
+        let __v_28: G = (__v_22 + __v_27);
+        let __v_29: G = (__v_20 + __v_28);
+        let __v_30: G = (__v_18 + __v_29);
+        let __v_31: G = (__v_16 + __v_30);
+        let __v_32: G = (__v_14 + __v_31);
+        let __v_33: G = (__v_4 + __v_32);
+        let __v_34: G = G::from_u64(0);
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0, __v_1, __v_12]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_35: G = __r_arr[0];
+        let __v_36: G = __r_arr[1];
+        let __v_37: G = (__v_0 * __v_35);
+        let __v_38: G = G::from_u64(7);
+        let __v_39: G = (__v_1 * __v_36);
+        let __v_40: G = (__v_38 * __v_39);
+        let __v_41: G = (__v_37 + __v_40);
+        let __v_42: G = (__v_0 * __v_36);
+        let __v_43: G = (__v_1 * __v_35);
+        let __v_44: G = (__v_42 + __v_43);
+        let __v_45: G = (__v_33 + __v_41);
+        let __v_46: G = (__v_34 + __v_44);
+        let __ret: [G; OUT_196] = [__v_45, __v_46];
+        if !unconstrained { record.virt += record.function_queries[196].weight(); } record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_197: usize = 7;
+const IN_197: usize = 7;
+const OUT_197: usize = 2;
+fn aiur_fn_197(
+  inp: [G; IN_197],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_197], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_7: G = __loaded[0];
+    let __v_8: G = __loaded[1];
+    let __v_9: G = __loaded[2];
+    match __v_7.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_197] = [__v_0, __v_1];
+        if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_5, __v_6, __v_8]; 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 { let __r = record.function_queries[196].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+        let __v_11: G = __r_arr[1];
+        let __v_12: G = (__v_3 + __v_10);
+        let __v_13: G = (__v_4 + __v_11);
+        let __v_14: G = (__v_12 * __v_12);
+        let __v_15: G = G::from_u64(7);
+        let __v_16: G = (__v_13 * __v_13);
+        let __v_17: G = (__v_15 * __v_16);
+        let __v_18: G = (__v_14 - __v_17);
+        let __v_19: G = g_inverse_value(__v_18);
+        let __v_20: G = (__v_18 * __v_19);
+        let __v_21: G = G::from_u64(1);
+        let __v_22: G = (__v_20 - __v_21);
+        let __v_23: G = (__v_18 * __v_22);
+        let __v_24: G = G::from_u64(0);
+        if (__v_23 != __v_24) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        }
+        let __v_25: G = (__v_19 * __v_22);
+        let __v_26: G = G::from_u64(0);
+        if (__v_25 != __v_26) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        }
+        let __v_27: G = (__v_12 * __v_19);
+        let __v_28: G = G::from_u64(0);
+        let __v_29: G = (__v_28 - __v_13);
+        let __v_30: G = (__v_29 * __v_19);
+        let __v_31: G = (__v_0 + __v_27);
+        let __v_32: G = (__v_1 + __v_30);
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_33: G = __r_arr[0];
+        let __v_34: G = __r_arr[1];
+        let __ret: [G; OUT_197] = [__v_33, __v_34];
+        if !unconstrained { record.virt += record.function_queries[197].weight(); } record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_198: usize = 38;
+const IN_198: usize = 38;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_198], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __v_21: G = inp[21];
+    let __v_22: G = inp[22];
+    let __v_23: G = inp[23];
+    let __v_24: G = inp[24];
+    let __v_25: G = inp[25];
+    let __v_26: G = inp[26];
+    let __v_27: G = inp[27];
+    let __v_28: G = inp[28];
+    let __v_29: G = inp[29];
+    let __v_30: G = inp[30];
+    let __v_31: G = inp[31];
+    let __v_32: G = inp[32];
+    let __v_33: G = inp[33];
+    let __v_34: G = inp[34];
+    let __v_35: G = inp[35];
+    let __v_36: G = inp[36];
+    let __v_37: G = inp[37];
+    match __v_0.as_canonical_u64() {
+      _ => {
+        match __v_0.as_canonical_u64() {
+          _ => {
+            match __v_12.as_canonical_u64() {
+              _ => {
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11, __v_12]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+                match __v_13.as_canonical_u64() {
+                  _ => {
+                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
+  0u64 => {
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_42];
+  },
+  1u64 => {
+    break '__mc_0 [__v_10];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+  },
+}
+ };
+                    let __v_40: G = __mc_out___mc_0[0];
+                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_17, __v_37]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_13, __v_41]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+                    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_40, __v_42]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
+                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_12, __v_43]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_44]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_45: G = __r_arr[0];
+                    let __v_46: G = G::from_u64(0);
+                    let __v_47: G = G::from_u64(109);
+                    let __v_48: G = G::from_u64(0);
+                    let __v_49: G = G::from_u64(117);
+                    let __v_50: G = G::from_u64(0);
+                    let __v_51: G = G::from_u64(108);
+                    let __v_52: G = G::from_u64(0);
+                    let __v_53: G = G::from_u64(116);
+                    let __v_54: G = G::from_u64(0);
+                    let __v_55: G = G::from_u64(105);
+                    let __v_56: G = G::from_u64(0);
+                    let __v_57: G = G::from_u64(45);
+                    let __v_58: G = G::from_u64(0);
+                    let __v_59: G = G::from_u64(115);
+                    let __v_60: G = G::from_u64(0);
+                    let __v_61: G = G::from_u64(116);
+                    let __v_62: G = G::from_u64(0);
+                    let __v_63: G = G::from_u64(97);
+                    let __v_64: G = G::from_u64(0);
+                    let __v_65: G = G::from_u64(114);
+                    let __v_66: G = G::from_u64(0);
+                    let __v_67: G = G::from_u64(107);
+                    let __v_68: G = G::from_u64(0);
+                    let __v_69: G = G::from_u64(47);
+                    let __v_70: G = G::from_u64(0);
+                    let __v_71: G = G::from_u64(118);
+                    let __v_72: G = G::from_u64(0);
+                    let __v_73: G = G::from_u64(48);
+                    let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __v_88: G = G::from_u64(1);
+                    let __v_89: G = G::from_u64(1);
+                    let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_87, __v_90]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_91: G = __r_arr[0];
+                    let __v_92: G = __r_arr[1];
+                    let __v_93: G = __r_arr[2];
+                    let __v_94: G = __r_arr[3];
+                    let __v_95: G = __r_arr[4];
+                    let __v_96: G = __r_arr[5];
+                    let __v_97: G = __r_arr[6];
+                    let __v_98: G = __r_arr[7];
+                    let __v_99: G = __r_arr[8];
+                    let __v_100: G = __r_arr[9];
+                    let __v_101: G = __r_arr[10];
+                    let __v_102: G = __r_arr[11];
+                    let __v_103: G = __r_arr[12];
+                    let __v_104: G = __r_arr[13];
+                    let __v_105: G = __r_arr[14];
+                    let __v_106: G = __r_arr[15];
+                    let __v_107: G = __r_arr[16];
+                    let __v_108: G = __r_arr[17];
+                    let __v_109: G = G::from_u64(1);
+                    let __v_110: G = G::from_u64(1);
+                    let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_112: G = __r_arr[0];
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_113: G = __r_arr[0];
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_107, __v_113]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_114: G = __r_arr[0];
+                    let __v_115: G = G::from_u64(1);
+                    let __v_116: G = G::from_u64(1);
+                    let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_114, __v_117]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_118: G = __r_arr[0];
+                    let __v_119: G = __r_arr[1];
+                    let __v_120: G = __r_arr[2];
+                    let __v_121: G = __r_arr[3];
+                    let __v_122: G = __r_arr[4];
+                    let __v_123: G = __r_arr[5];
+                    let __v_124: G = __r_arr[6];
+                    let __v_125: G = __r_arr[7];
+                    let __v_126: G = __r_arr[8];
+                    let __v_127: G = __r_arr[9];
+                    let __v_128: G = __r_arr[10];
+                    let __v_129: G = __r_arr[11];
+                    let __v_130: G = __r_arr[12];
+                    let __v_131: G = __r_arr[13];
+                    let __v_132: G = __r_arr[14];
+                    let __v_133: G = __r_arr[15];
+                    let __v_134: G = __r_arr[16];
+                    let __v_135: G = __r_arr[17];
+                    let __v_136: G = G::from_u64(1);
+                    let __v_137: G = G::from_u64(1);
+                    let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_139: G = __r_arr[0];
+                    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_140: G = __r_arr[0];
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_134, __v_140]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_141: G = __r_arr[0];
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_141, __v_14]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_142: G = __r_arr[0];
+                    let __v_143: G = G::from_u64(1);
+                    let __v_144: G = G::from_u64(1);
+                    let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_16, __v_145]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_146: G = __r_arr[0];
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_142, __v_146]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_147: G = __r_arr[0];
+                    let __v_148: G = G::from_u64(1);
+                    let __v_149: G = G::from_u64(1);
+                    let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_147, __v_150]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+                    let __v_152: G = __r_arr[1];
+                    let __v_153: G = __r_arr[2];
+                    let __v_154: G = __r_arr[3];
+                    let __v_155: G = __r_arr[4];
+                    let __v_156: G = __r_arr[5];
+                    let __v_157: G = __r_arr[6];
+                    let __v_158: G = __r_arr[7];
+                    let __v_159: G = __r_arr[8];
+                    let __v_160: G = __r_arr[9];
+                    let __v_161: G = __r_arr[10];
+                    let __v_162: G = __r_arr[11];
+                    let __v_163: G = __r_arr[12];
+                    let __v_164: G = __r_arr[13];
+                    let __v_165: G = __r_arr[14];
+                    let __v_166: G = __r_arr[15];
+                    let __v_167: G = __r_arr[16];
+                    let __v_168: G = __r_arr[17];
+                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_167, __v_15]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_169: G = __r_arr[0];
+                    let __v_170: G = G::from_u64(1);
+                    let __v_171: G = G::from_u64(1);
+                    let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_169, __v_172]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_173: G = __r_arr[0];
+                    let __v_174: G = __r_arr[1];
+                    let __v_175: G = __r_arr[2];
+                    let __v_176: G = __r_arr[3];
+                    let __v_177: G = __r_arr[4];
+                    let __v_178: G = __r_arr[5];
+                    let __v_179: G = __r_arr[6];
+                    let __v_180: G = __r_arr[7];
+                    let __v_181: G = __r_arr[8];
+                    let __v_182: G = __r_arr[9];
+                    let __v_183: G = __r_arr[10];
+                    let __v_184: G = __r_arr[11];
+                    let __v_185: G = __r_arr[12];
+                    let __v_186: G = __r_arr[13];
+                    let __v_187: G = __r_arr[14];
+                    let __v_188: G = __r_arr[15];
+                    let __v_189: G = __r_arr[16];
+                    let __v_190: G = __r_arr[17];
+                    let __v_191: G = G::from_u64(256);
+                    let __v_192: G = (__v_191 * __v_92);
+                    let __v_193: G = G::from_u64(65536);
+                    let __v_194: G = (__v_193 * __v_93);
+                    let __v_195: G = G::from_u64(16777216);
+                    let __v_196: G = (__v_195 * __v_94);
+                    let __v_197: G = G::from_u64(4294967296);
+                    let __v_198: G = (__v_197 * __v_95);
+                    let __v_199: G = G::from_u64(1099511627776);
+                    let __v_200: G = (__v_199 * __v_96);
+                    let __v_201: G = G::from_u64(281474976710656);
+                    let __v_202: G = (__v_201 * __v_97);
+                    let __v_203: G = G::from_u64(72057594037927936);
+                    let __v_204: G = (__v_203 * __v_98);
+                    let __v_205: G = (__v_202 + __v_204);
+                    let __v_206: G = (__v_200 + __v_205);
+                    let __v_207: G = (__v_198 + __v_206);
+                    let __v_208: G = (__v_196 + __v_207);
+                    let __v_209: G = (__v_194 + __v_208);
+                    let __v_210: G = (__v_192 + __v_209);
+                    let __v_211: G = (__v_91 + __v_210);
+                    let __v_212: G = G::from_u64(256);
+                    let __v_213: G = (__v_212 * __v_100);
+                    let __v_214: G = G::from_u64(65536);
+                    let __v_215: G = (__v_214 * __v_101);
+                    let __v_216: G = G::from_u64(16777216);
+                    let __v_217: G = (__v_216 * __v_102);
+                    let __v_218: G = G::from_u64(4294967296);
+                    let __v_219: G = (__v_218 * __v_103);
+                    let __v_220: G = G::from_u64(1099511627776);
+                    let __v_221: G = (__v_220 * __v_104);
+                    let __v_222: G = G::from_u64(281474976710656);
+                    let __v_223: G = (__v_222 * __v_105);
+                    let __v_224: G = G::from_u64(72057594037927936);
+                    let __v_225: G = (__v_224 * __v_106);
+                    let __v_226: G = (__v_223 + __v_225);
+                    let __v_227: G = (__v_221 + __v_226);
+                    let __v_228: G = (__v_219 + __v_227);
+                    let __v_229: G = (__v_217 + __v_228);
+                    let __v_230: G = (__v_215 + __v_229);
+                    let __v_231: G = (__v_213 + __v_230);
+                    let __v_232: G = (__v_99 + __v_231);
+                    let __v_233: G = G::from_u64(256);
+                    let __v_234: G = (__v_233 * __v_119);
+                    let __v_235: G = G::from_u64(65536);
+                    let __v_236: G = (__v_235 * __v_120);
+                    let __v_237: G = G::from_u64(16777216);
+                    let __v_238: G = (__v_237 * __v_121);
+                    let __v_239: G = G::from_u64(4294967296);
+                    let __v_240: G = (__v_239 * __v_122);
+                    let __v_241: G = G::from_u64(1099511627776);
+                    let __v_242: G = (__v_241 * __v_123);
+                    let __v_243: G = G::from_u64(281474976710656);
+                    let __v_244: G = (__v_243 * __v_124);
+                    let __v_245: G = G::from_u64(72057594037927936);
+                    let __v_246: G = (__v_245 * __v_125);
+                    let __v_247: G = (__v_244 + __v_246);
+                    let __v_248: G = (__v_242 + __v_247);
+                    let __v_249: G = (__v_240 + __v_248);
+                    let __v_250: G = (__v_238 + __v_249);
+                    let __v_251: G = (__v_236 + __v_250);
+                    let __v_252: G = (__v_234 + __v_251);
+                    let __v_253: G = (__v_118 + __v_252);
+                    let __v_254: G = G::from_u64(256);
+                    let __v_255: G = (__v_254 * __v_127);
+                    let __v_256: G = G::from_u64(65536);
+                    let __v_257: G = (__v_256 * __v_128);
+                    let __v_258: G = G::from_u64(16777216);
+                    let __v_259: G = (__v_258 * __v_129);
+                    let __v_260: G = G::from_u64(4294967296);
+                    let __v_261: G = (__v_260 * __v_130);
+                    let __v_262: G = G::from_u64(1099511627776);
+                    let __v_263: G = (__v_262 * __v_131);
+                    let __v_264: G = G::from_u64(281474976710656);
+                    let __v_265: G = (__v_264 * __v_132);
+                    let __v_266: G = G::from_u64(72057594037927936);
+                    let __v_267: G = (__v_266 * __v_133);
+                    let __v_268: G = (__v_265 + __v_267);
+                    let __v_269: G = (__v_263 + __v_268);
+                    let __v_270: G = (__v_261 + __v_269);
+                    let __v_271: G = (__v_259 + __v_270);
+                    let __v_272: G = (__v_257 + __v_271);
+                    let __v_273: G = (__v_255 + __v_272);
+                    let __v_274: G = (__v_126 + __v_273);
+                    let __v_275: G = G::from_u64(256);
+                    let __v_276: G = (__v_275 * __v_152);
+                    let __v_277: G = G::from_u64(65536);
+                    let __v_278: G = (__v_277 * __v_153);
+                    let __v_279: G = G::from_u64(16777216);
+                    let __v_280: G = (__v_279 * __v_154);
+                    let __v_281: G = G::from_u64(4294967296);
+                    let __v_282: G = (__v_281 * __v_155);
+                    let __v_283: G = G::from_u64(1099511627776);
+                    let __v_284: G = (__v_283 * __v_156);
+                    let __v_285: G = G::from_u64(281474976710656);
+                    let __v_286: G = (__v_285 * __v_157);
+                    let __v_287: G = G::from_u64(72057594037927936);
+                    let __v_288: G = (__v_287 * __v_158);
+                    let __v_289: G = (__v_286 + __v_288);
+                    let __v_290: G = (__v_284 + __v_289);
+                    let __v_291: G = (__v_282 + __v_290);
+                    let __v_292: G = (__v_280 + __v_291);
+                    let __v_293: G = (__v_278 + __v_292);
+                    let __v_294: G = (__v_276 + __v_293);
+                    let __v_295: G = (__v_151 + __v_294);
+                    let __v_296: G = G::from_u64(256);
+                    let __v_297: G = (__v_296 * __v_160);
+                    let __v_298: G = G::from_u64(65536);
+                    let __v_299: G = (__v_298 * __v_161);
+                    let __v_300: G = G::from_u64(16777216);
+                    let __v_301: G = (__v_300 * __v_162);
+                    let __v_302: G = G::from_u64(4294967296);
+                    let __v_303: G = (__v_302 * __v_163);
+                    let __v_304: G = G::from_u64(1099511627776);
+                    let __v_305: G = (__v_304 * __v_164);
+                    let __v_306: G = G::from_u64(281474976710656);
+                    let __v_307: G = (__v_306 * __v_165);
+                    let __v_308: G = G::from_u64(72057594037927936);
+                    let __v_309: G = (__v_308 * __v_166);
+                    let __v_310: G = (__v_307 + __v_309);
+                    let __v_311: G = (__v_305 + __v_310);
+                    let __v_312: G = (__v_303 + __v_311);
+                    let __v_313: G = (__v_301 + __v_312);
+                    let __v_314: G = (__v_299 + __v_313);
+                    let __v_315: G = (__v_297 + __v_314);
+                    let __v_316: G = (__v_159 + __v_315);
+                    let __v_317: G = G::from_u64(256);
+                    let __v_318: G = (__v_317 * __v_174);
+                    let __v_319: G = G::from_u64(65536);
+                    let __v_320: G = (__v_319 * __v_175);
+                    let __v_321: G = G::from_u64(16777216);
+                    let __v_322: G = (__v_321 * __v_176);
+                    let __v_323: G = G::from_u64(4294967296);
+                    let __v_324: G = (__v_323 * __v_177);
+                    let __v_325: G = G::from_u64(1099511627776);
+                    let __v_326: G = (__v_325 * __v_178);
+                    let __v_327: G = G::from_u64(281474976710656);
+                    let __v_328: G = (__v_327 * __v_179);
+                    let __v_329: G = G::from_u64(72057594037927936);
+                    let __v_330: G = (__v_329 * __v_180);
+                    let __v_331: G = (__v_328 + __v_330);
+                    let __v_332: G = (__v_326 + __v_331);
+                    let __v_333: G = (__v_324 + __v_332);
+                    let __v_334: G = (__v_322 + __v_333);
+                    let __v_335: G = (__v_320 + __v_334);
+                    let __v_336: G = (__v_318 + __v_335);
+                    let __v_337: G = (__v_173 + __v_336);
+                    let __v_338: G = G::from_u64(256);
+                    let __v_339: G = (__v_338 * __v_182);
+                    let __v_340: G = G::from_u64(65536);
+                    let __v_341: G = (__v_340 * __v_183);
+                    let __v_342: G = G::from_u64(16777216);
+                    let __v_343: G = (__v_342 * __v_184);
+                    let __v_344: G = G::from_u64(4294967296);
+                    let __v_345: G = (__v_344 * __v_185);
+                    let __v_346: G = G::from_u64(1099511627776);
+                    let __v_347: G = (__v_346 * __v_186);
+                    let __v_348: G = G::from_u64(281474976710656);
+                    let __v_349: G = (__v_348 * __v_187);
+                    let __v_350: G = G::from_u64(72057594037927936);
+                    let __v_351: G = (__v_350 * __v_188);
+                    let __v_352: G = (__v_349 + __v_351);
+                    let __v_353: G = (__v_347 + __v_352);
+                    let __v_354: G = (__v_345 + __v_353);
+                    let __v_355: G = (__v_343 + __v_354);
+                    let __v_356: G = (__v_341 + __v_355);
+                    let __v_357: G = (__v_339 + __v_356);
+                    let __v_358: G = (__v_181 + __v_357);
+                    let __v_359: G = G::from_u64(0);
+                    let __v_360: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_361: G = __r_arr[0];
+                    let __v_362: G = __r_arr[1];
+                    let __v_363: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_364: G = __r_arr[0];
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_38]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_365: G = __r_arr[0];
+                    match __v_18.as_canonical_u64() {
+                      _ => {
+                        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_18]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_366: G = __r_arr[0];
+                        let __v_367: G = G::from_u64(1);
+                        let __v_368: G = G::from_u64(1);
+                        let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() {
+  0u64 => {
+    break '__mc_1 [__v_369];
+  },
+  1u64 => {
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_33, __v_369]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_370: G = __r_arr[0];
+    break '__mc_1 [__v_370];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64()));
+  },
+}
+ };
+                        let __v_370: G = __mc_out___mc_1[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_31, __v_370]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_371: G = __r_arr[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_35, __v_371]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_372: G = __r_arr[0];
+                        let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_34, __v_372]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_373: G = __r_arr[0];
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_189, __v_373]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_374: G = __r_arr[0];
+                        let __v_375: G = G::from_u64(1);
+                        let __v_376: G = G::from_u64(1);
+                        let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_374, __v_377]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_378: G = __r_arr[0];
+                        let __v_379: G = __r_arr[1];
+                        let __v_380: G = __r_arr[2];
+                        let __v_381: G = __r_arr[3];
+                        let __v_382: G = __r_arr[4];
+                        let __v_383: G = __r_arr[5];
+                        let __v_384: G = __r_arr[6];
+                        let __v_385: G = __r_arr[7];
+                        let __v_386: G = __r_arr[8];
+                        let __v_387: G = __r_arr[9];
+                        let __v_388: G = __r_arr[10];
+                        let __v_389: G = __r_arr[11];
+                        let __v_390: G = __r_arr[12];
+                        let __v_391: G = __r_arr[13];
+                        let __v_392: G = __r_arr[14];
+                        let __v_393: G = __r_arr[15];
+                        let __v_394: G = __r_arr[16];
+                        let __v_395: G = __r_arr[17];
+                        let __v_396: G = G::from_u64(256);
+                        let __v_397: G = (__v_396 * __v_379);
+                        let __v_398: G = G::from_u64(65536);
+                        let __v_399: G = (__v_398 * __v_380);
+                        let __v_400: G = G::from_u64(16777216);
+                        let __v_401: G = (__v_400 * __v_381);
+                        let __v_402: G = G::from_u64(4294967296);
+                        let __v_403: G = (__v_402 * __v_382);
+                        let __v_404: G = G::from_u64(1099511627776);
+                        let __v_405: G = (__v_404 * __v_383);
+                        let __v_406: G = G::from_u64(281474976710656);
+                        let __v_407: G = (__v_406 * __v_384);
+                        let __v_408: G = G::from_u64(72057594037927936);
+                        let __v_409: G = (__v_408 * __v_385);
+                        let __v_410: G = (__v_407 + __v_409);
+                        let __v_411: G = (__v_405 + __v_410);
+                        let __v_412: G = (__v_403 + __v_411);
+                        let __v_413: G = (__v_401 + __v_412);
+                        let __v_414: G = (__v_399 + __v_413);
+                        let __v_415: G = (__v_397 + __v_414);
+                        let __v_416: G = (__v_378 + __v_415);
+                        let __v_417: G = G::from_u64(256);
+                        let __v_418: G = (__v_417 * __v_387);
+                        let __v_419: G = G::from_u64(65536);
+                        let __v_420: G = (__v_419 * __v_388);
+                        let __v_421: G = G::from_u64(16777216);
+                        let __v_422: G = (__v_421 * __v_389);
+                        let __v_423: G = G::from_u64(4294967296);
+                        let __v_424: G = (__v_423 * __v_390);
+                        let __v_425: G = G::from_u64(1099511627776);
+                        let __v_426: G = (__v_425 * __v_391);
+                        let __v_427: G = G::from_u64(281474976710656);
+                        let __v_428: G = (__v_427 * __v_392);
+                        let __v_429: G = G::from_u64(72057594037927936);
+                        let __v_430: G = (__v_429 * __v_393);
+                        let __v_431: G = (__v_428 + __v_430);
+                        let __v_432: G = (__v_426 + __v_431);
+                        let __v_433: G = (__v_424 + __v_432);
+                        let __v_434: G = (__v_422 + __v_433);
+                        let __v_435: G = (__v_420 + __v_434);
+                        let __v_436: G = (__v_418 + __v_435);
+                        let __v_437: G = (__v_386 + __v_436);
+                        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_394, __v_18, __v_19, __v_5]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_438: G = __r_arr[0];
+                        let __v_439: G = __r_arr[1];
+                        let __v_440: G = G::from_u64(1);
+                        let __v_441: G = G::from_u64(1);
+                        let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_22, __v_442]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_443: G = __r_arr[0];
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_439, __v_443]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_444: G = __r_arr[0];
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_444, __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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_445: G = __r_arr[0];
+                        let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_446: G = __r_arr[0];
+                        let __v_447: G = __r_arr[1];
+                        let __v_448: G = (__v_366 + __v_0);
+                        let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_4, __v_448]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_449: G = __r_arr[0];
+                        let __v_450: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_20, __v_21, __v_450, __v_4]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_451: G = __r_arr[0];
+                        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_452: G = __r_arr[0];
+                        let __v_453: G = G::from_u64(0);
+                        if (__v_1 != __v_453) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_453.as_canonical_u64(), msg: None });
+                        }
+                        let __v_454: G = G::from_u64(0);
+                        if (__v_2 != __v_454) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
+                        }
+                        let __v_455: G = G::from_u64(1);
+                        if (__v_3 != __v_455) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_456: G = __r_arr[0];
+                        let __v_457: G = G::from_u64(1);
+                        if (__v_456 != __v_457) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None });
+                        }
+                        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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_458: G = __r_arr[0];
+                        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_459: G = __r_arr[0];
+                        let __v_460: G = (__v_458 - __v_459);
+                        let __v_461: G = G::from_bool((__v_460 == G::ZERO));
+                        let __v_462: G = G::from_u64(1);
+                        if (__v_461 != __v_462) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_38]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_463: G = __r_arr[0];
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_464: G = __r_arr[0];
+                        let __v_465: G = (__v_463 - __v_464);
+                        let __v_466: G = G::from_bool((__v_465 == G::ZERO));
+                        let __v_467: G = G::from_u64(1);
+                        if (__v_466 != __v_467) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19]; 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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_468: G = __r_arr[0];
+                        let __v_469: G = (__v_468 - __v_366);
+                        let __v_470: G = G::from_bool((__v_469 == G::ZERO));
+                        let __v_471: G = G::from_u64(1);
+                        if (__v_470 != __v_471) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_20]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_472: G = __r_arr[0];
+                        let __v_473: G = G::from_u64(3);
+                        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_32, __v_33]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_474: G = __r_arr[0];
+                        let __v_475: G = (__v_473 + __v_474);
+                        if (__v_472 != __v_475) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_21]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_476: G = __r_arr[0];
+                        let __v_477: G = (__v_476 - __v_366);
+                        let __v_478: G = G::from_bool((__v_477 == G::ZERO));
+                        let __v_479: G = G::from_u64(1);
+                        if (__v_478 != __v_479) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_480: G = __r_arr[0];
+                        let __v_481: G = G::from_u64(1);
+                        if (__v_480 != __v_481) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None });
+                        }
+                        let __v_482: G = G::from_u64(33);
+                        let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                        let __v_484: G = G::from_u64(1);
+                        if (__v_483 != __v_484) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None });
+                        }
+                        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_485: G = __r_arr[0];
+                        let __v_486: G = G::from_u64(1);
+                        if (__v_485 != __v_486) {
+                          return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None });
+                        }
+                        let __v_487: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_488: G = __r_arr[0];
+                        let __ret: [G; OUT_198] = [__v_488];
+                        if !unconstrained { record.virt += record.function_queries[198].weight(); } record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+            }
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_199: usize = 1;
+const IN_199: usize = 1;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_199], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_199] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = (__v_2 - __v_4);
+        let __v_6: G = (__v_2 * __v_5);
+        let __v_7: G = G::from_u64(0);
+        if (__v_6 != __v_7) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
+        }
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        let __ret: [G; OUT_199] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[199].weight(); } record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_200: usize = 2;
+const IN_200: usize = 2;
+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_200], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_200] = [__v_12];
+        if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_10: G = __loaded[0];
+        let __v_11: G = __loaded[1];
+        let __v_12: G = __loaded[2];
+        match __v_10.as_canonical_u64() {
+          0u64 => {
+            match __v_11.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+                let __ret: [G; OUT_200] = [__v_13];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_13: G = G::from_u64(0);
+                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9, __v_12]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+                let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_200] = [__v_15];
+                if !unconstrained { record.virt += record.function_queries[200].weight(); } record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+            }
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_201: usize = 2;
+const IN_201: usize = 2;
+const OUT_201: usize = 1;
+fn aiur_fn_201(
+  inp: [G; IN_201],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_201], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_201] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_6: G = __loaded[0];
+        let __v_7: G = __loaded[1];
+        let __v_8: G = __loaded[2];
+        match __v_6.as_canonical_u64() {
+          0u64 => {
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_8]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+                let __ret: [G; OUT_201] = [__v_9];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(0);
+                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_8]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __ret: [G; OUT_201] = [__v_11];
+                if !unconstrained { record.virt += record.function_queries[201].weight(); } record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
             }
-            let __v_106: G = (__v_91 * __v_98);
-            let __v_107: G = G::from_u64(0);
-            let __v_108: G = (__v_107 - __v_92);
-            let __v_109: G = (__v_108 * __v_98);
-            let __v_110: G = (__v_50 * __v_106);
-            let __v_111: G = G::from_u64(7);
-            let __v_112: G = (__v_51 * __v_109);
-            let __v_113: G = (__v_111 * __v_112);
-            let __v_114: G = (__v_110 + __v_113);
-            let __v_115: G = (__v_50 * __v_109);
-            let __v_116: G = (__v_51 * __v_106);
-            let __v_117: G = (__v_115 + __v_116);
-            let __v_118: G = G::from_u64(0);
-            let __v_119: G = (__v_18 - __v_53);
-            let __v_120: G = (__v_19 - __v_118);
-            let __v_121: G = (__v_50 * __v_50);
-            let __v_122: G = G::from_u64(7);
-            let __v_123: G = (__v_51 * __v_51);
-            let __v_124: G = (__v_122 * __v_123);
-            let __v_125: G = (__v_121 - __v_124);
-            let __v_126: G = g_inverse_value(__v_125);
-            let __v_127: G = (__v_125 * __v_126);
-            let __v_128: G = G::from_u64(1);
-            let __v_129: G = (__v_127 - __v_128);
-            let __v_130: G = (__v_125 * __v_129);
-            let __v_131: G = G::from_u64(0);
-            if (__v_130 != __v_131) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_130.as_canonical_u64(), rhs: __v_131.as_canonical_u64(), msg: None });
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 2;
+fn aiur_fn_202(
+  inp: [G; IN_202],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_202], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_1]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_202] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[202].weight(); } record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_203: usize = 2;
+const IN_203: usize = 2;
+const OUT_203: usize = 2;
+fn aiur_fn_203(
+  inp: [G; IN_203],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_203], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_203] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_3, __v_2]; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+        let __v_5: G = __r_arr[1];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_1 - __v_6);
+        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_7]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_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_4, __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_203] = [__v_11, __v_9];
+        if !unconstrained { record.virt += record.function_queries[203].weight(); } record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_204: usize = 1;
+const IN_204: usize = 1;
+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_204], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2, __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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __ret: [G; OUT_204] = [__v_3, __v_4];
+    if !unconstrained { record.virt += record.function_queries[204].weight(); } record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_205: usize = 2;
+const IN_205: usize = 2;
+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_205], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_1.as_canonical_u64() {
+      0u64 => {
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = G::from_u64(1);
+        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_205] = [__v_4, __v_0];
+        if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[26].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = __r_arr[0];
+        let __v_3: G = __r_arr[1];
+        let __v_4: G = __r_arr[2];
+        let __v_5: G = __r_arr[3];
+        let __v_6: G = __r_arr[4];
+        let __v_7: G = __r_arr[5];
+        let __v_8: G = __r_arr[6];
+        let __v_9: G = __r_arr[7];
+        let __v_10: G = __r_arr[8];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_12]; 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 { let __r = record.function_queries[205].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __v_15: G = G::from_u64(0);
+        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_205] = [__v_16, __v_14];
+        if !unconstrained { record.virt += record.function_queries[205].weight(); } record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+    }
+  })
+}
+
+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_206], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_7: G = __loaded[0];
+            let __v_8: G = __loaded[1];
+            let __v_9: G = __loaded[2];
+            match __v_7.as_canonical_u64() {
+              0u64 => {
+                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                let __v_10: G = __loaded[0];
+                let __v_11: G = __loaded[1];
+                let __v_12: G = __loaded[2];
+                match __v_10.as_canonical_u64() {
+                  0u64 => {
+                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                    let __v_13: G = __loaded[0];
+                    let __v_14: G = __loaded[1];
+                    let __v_15: G = __loaded[2];
+                    match __v_13.as_canonical_u64() {
+                      0u64 => {
+                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                        let __v_16: G = __loaded[0];
+                        let __v_17: G = __loaded[1];
+                        let __v_18: G = __loaded[2];
+                        match __v_16.as_canonical_u64() {
+                          0u64 => {
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_19: G = __loaded[0];
+                            let __v_20: G = __loaded[1];
+                            let __v_21: G = __loaded[2];
+                            match __v_19.as_canonical_u64() {
+                              0u64 => {
+                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                let __v_22: G = __loaded[0];
+                                let __v_23: G = __loaded[1];
+                                let __v_24: G = __loaded[2];
+                                match __v_22.as_canonical_u64() {
+                                  0u64 => {
+                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+                                    let __v_26: G = __loaded[1];
+                                    let __v_27: G = __loaded[2];
+                                    match __v_25.as_canonical_u64() {
+                                      0u64 => {
+                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                        let __v_28: G = __loaded[0];
+                                        let __v_29: G = __loaded[1];
+                                        let __v_30: G = __loaded[2];
+                                        match __v_28.as_canonical_u64() {
+                                          0u64 => {
+                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                            let __v_31: G = __loaded[0];
+                                            let __v_32: G = __loaded[1];
+                                            let __v_33: G = __loaded[2];
+                                            match __v_31.as_canonical_u64() {
+                                              0u64 => {
+                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                let __v_34: G = __loaded[0];
+                                                let __v_35: G = __loaded[1];
+                                                let __v_36: G = __loaded[2];
+                                                match __v_34.as_canonical_u64() {
+                                                  0u64 => {
+                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                    let __v_37: G = __loaded[0];
+                                                    let __v_38: G = __loaded[1];
+                                                    let __v_39: G = __loaded[2];
+                                                    match __v_37.as_canonical_u64() {
+                                                      0u64 => {
+                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                        let __v_40: G = __loaded[0];
+                                                        let __v_41: G = __loaded[1];
+                                                        let __v_42: G = __loaded[2];
+                                                        match __v_40.as_canonical_u64() {
+                                                          0u64 => {
+                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                            let __v_43: G = __loaded[0];
+                                                            let __v_44: G = __loaded[1];
+                                                            let __v_45: G = __loaded[2];
+                                                            match __v_43.as_canonical_u64() {
+                                                              0u64 => {
+                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                let __v_46: G = __loaded[0];
+                                                                let __v_47: G = __loaded[1];
+                                                                let __v_48: G = __loaded[2];
+                                                                match __v_46.as_canonical_u64() {
+                                                                  0u64 => {
+                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                    let __v_49: G = __loaded[0];
+                                                                    let __v_50: G = __loaded[1];
+                                                                    let __v_51: G = __loaded[2];
+                                                                    match __v_49.as_canonical_u64() {
+                                                                      0u64 => {
+                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                        let __v_52: G = __loaded[0];
+                                                                        let __v_53: G = __loaded[1];
+                                                                        let __v_54: G = __loaded[2];
+                                                                        match __v_52.as_canonical_u64() {
+                                                                          0u64 => {
+                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                            let __v_55: G = __loaded[0];
+                                                                            let __v_56: G = __loaded[1];
+                                                                            let __v_57: G = __loaded[2];
+                                                                            match __v_55.as_canonical_u64() {
+                                                                              0u64 => {
+                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                let __v_58: G = __loaded[0];
+                                                                                let __v_59: G = __loaded[1];
+                                                                                let __v_60: G = __loaded[2];
+                                                                                match __v_58.as_canonical_u64() {
+                                                                                  0u64 => {
+                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                    let __v_61: G = __loaded[0];
+                                                                                    let __v_62: G = __loaded[1];
+                                                                                    let __v_63: G = __loaded[2];
+                                                                                    match __v_61.as_canonical_u64() {
+                                                                                      0u64 => {
+                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                        let __v_64: G = __loaded[0];
+                                                                                        let __v_65: G = __loaded[1];
+                                                                                        let __v_66: G = __loaded[2];
+                                                                                        match __v_64.as_canonical_u64() {
+                                                                                          0u64 => {
+                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                            let __v_67: G = __loaded[0];
+                                                                                            let __v_68: G = __loaded[1];
+                                                                                            let __v_69: G = __loaded[2];
+                                                                                            match __v_67.as_canonical_u64() {
+                                                                                              0u64 => {
+                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                let __v_70: G = __loaded[0];
+                                                                                                let __v_71: G = __loaded[1];
+                                                                                                let __v_72: G = __loaded[2];
+                                                                                                match __v_70.as_canonical_u64() {
+                                                                                                  0u64 => {
+                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                    let __v_73: G = __loaded[0];
+                                                                                                    let __v_74: G = __loaded[1];
+                                                                                                    let __v_75: G = __loaded[2];
+                                                                                                    match __v_73.as_canonical_u64() {
+                                                                                                      0u64 => {
+                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                        let __v_76: G = __loaded[0];
+                                                                                                        let __v_77: G = __loaded[1];
+                                                                                                        let __v_78: G = __loaded[2];
+                                                                                                        match __v_76.as_canonical_u64() {
+                                                                                                          0u64 => {
+                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                            let __v_79: G = __loaded[0];
+                                                                                                            let __v_80: G = __loaded[1];
+                                                                                                            let __v_81: G = __loaded[2];
+                                                                                                            match __v_79.as_canonical_u64() {
+                                                                                                              0u64 => {
+                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                let __v_82: G = __loaded[0];
+                                                                                                                let __v_83: G = __loaded[1];
+                                                                                                                let __v_84: G = __loaded[2];
+                                                                                                                match __v_82.as_canonical_u64() {
+                                                                                                                  0u64 => {
+                                                                                                                    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                    let __v_85: G = __loaded[0];
+                                                                                                                    let __v_86: G = __loaded[1];
+                                                                                                                    let __v_87: G = __loaded[2];
+                                                                                                                    match __v_85.as_canonical_u64() {
+                                                                                                                      0u64 => {
+                                                                                                                        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                        let __v_88: G = __loaded[0];
+                                                                                                                        let __v_89: G = __loaded[1];
+                                                                                                                        let __v_90: G = __loaded[2];
+                                                                                                                        match __v_88.as_canonical_u64() {
+                                                                                                                          0u64 => {
+                                                                                                                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                            let __v_91: G = __loaded[0];
+                                                                                                                            let __v_92: G = __loaded[1];
+                                                                                                                            let __v_93: G = __loaded[2];
+                                                                                                                            match __v_91.as_canonical_u64() {
+                                                                                                                              0u64 => {
+                                                                                                                                let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                                                                                                                                let __v_94: G = __loaded[0];
+                                                                                                                                let __v_95: G = __loaded[1];
+                                                                                                                                let __v_96: G = __loaded[2];
+                                                                                                                                match __v_94.as_canonical_u64() {
+                                                                                                                                  0u64 => {
+                                                                                                                                    let __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                                                                                                                                    let __ret: [G; OUT_206] = [__v_97, __v_96];
+                                                                                                                                    if !unconstrained { record.virt += record.function_queries[206].weight(); } record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                                                                                                                    return Ok(__ret);
+                                                                                                                                  },
+                                                                                                                                  _ => {
+                                                                                                                                    return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64()));
+                                                                                                                                  },
+                                                                                                                                }
+                                                                                                                              },
+                                                                                                                              _ => {
+                                                                                                                                return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64()));
+                                                                                                                              },
+                                                                                                                            }
+                                                                                                                          },
+                                                                                                                          _ => {
+                                                                                                                            return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64()));
+                                                                                                                          },
+                                                                                                                        }
+                                                                                                                      },
+                                                                                                                      _ => {
+                                                                                                                        return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64()));
+                                                                                                                      },
+                                                                                                                    }
+                                                                                                                  },
+                                                                                                                  _ => {
+                                                                                                                    return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64()));
+                                                                                                                  },
+                                                                                                                }
+                                                                                                              },
+                                                                                                              _ => {
+                                                                                                                return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64()));
+                                                                                                              },
+                                                                                                            }
+                                                                                                          },
+                                                                                                          _ => {
+                                                                                                            return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64()));
+                                                                                                          },
+                                                                                                        }
+                                                                                                      },
+                                                                                                      _ => {
+                                                                                                        return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64()));
+                                                                                                      },
+                                                                                                    }
+                                                                                                  },
+                                                                                                  _ => {
+                                                                                                    return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64()));
+                                                                                                  },
+                                                                                                }
+                                                                                              },
+                                                                                              _ => {
+                                                                                                return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64()));
+                                                                                              },
+                                                                                            }
+                                                                                          },
+                                                                                          _ => {
+                                                                                            return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64()));
+                                                                                          },
+                                                                                        }
+                                                                                      },
+                                                                                      _ => {
+                                                                                        return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64()));
+                                                                                      },
+                                                                                    }
+                                                                                  },
+                                                                                  _ => {
+                                                                                    return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64()));
+                                                                                  },
+                                                                                }
+                                                                              },
+                                                                              _ => {
+                                                                                return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64()));
+                                                                              },
+                                                                            }
+                                                                          },
+                                                                          _ => {
+                                                                            return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64()));
+                                                                          },
+                                                                        }
+                                                                      },
+                                                                      _ => {
+                                                                        return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64()));
+                                                                      },
+                                                                    }
+                                                                  },
+                                                                  _ => {
+                                                                    return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64()));
+                                                                  },
+                                                                }
+                                                              },
+                                                              _ => {
+                                                                return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64()));
+                                                              },
+                                                            }
+                                                          },
+                                                          _ => {
+                                                            return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64()));
+                                                          },
+                                                        }
+                                                      },
+                                                      _ => {
+                                                        return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64()));
+                                                      },
+                                                    }
+                                                  },
+                                                  _ => {
+                                                    return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64()));
+                                                  },
+                                                }
+                                              },
+                                              _ => {
+                                                return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+                                              },
+                                            }
+                                          },
+                                          _ => {
+                                            return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64()));
+                                          },
+                                        }
+                                      },
+                                      _ => {
+                                        return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64()));
+                                      },
+                                    }
+                                  },
+                                  _ => {
+                                    return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64()));
+                                  },
+                                }
+                              },
+                              _ => {
+                                return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64()));
+                              },
+                            }
+                          },
+                          _ => {
+                            return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64()));
+                          },
+                        }
+                      },
+                      _ => {
+                        return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64()));
+                      },
+                    }
+                  },
+                  _ => {
+                    return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+              },
             }
-            let __v_132: G = (__v_126 * __v_129);
-            let __v_133: G = G::from_u64(0);
-            if (__v_132 != __v_133) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_132.as_canonical_u64(), rhs: __v_133.as_canonical_u64(), msg: None });
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_207: usize = 2;
+const IN_207: usize = 2;
+const OUT_207: usize = 1;
+fn aiur_fn_207(
+  inp: [G; IN_207],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_207], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __v_34: G = G::from_u64(0);
+    let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_36: G = G::from_u64(0);
+    let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_38: G = G::from_u64(0);
+    let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_40: G = G::from_u64(0);
+    let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_42: G = G::from_u64(0);
+    let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_44: G = G::from_u64(0);
+    let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_46: G = G::from_u64(0);
+    let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = G::from_u64(0);
+    let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_70: G = G::from_u64(0);
+    let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_72: G = G::from_u64(0);
+    let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_74: G = G::from_u64(0);
+    let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_76: G = G::from_u64(0);
+    let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_78: G = G::from_u64(0);
+    let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_80: G = G::from_u64(0);
+    let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_82: G = G::from_u64(0);
+    let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_84: G = G::from_u64(0);
+    let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_86: G = G::from_u64(0);
+    let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_88: G = G::from_u64(0);
+    let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_90: G = G::from_u64(0);
+    let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_92: G = G::from_u64(0);
+    let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_94: G = G::from_u64(0);
+    let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __ret: [G; OUT_207] = [__v_97];
+    if !unconstrained { record.virt += record.function_queries[207].weight(); } record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_208: usize = 1;
+const IN_208: usize = 1;
+const OUT_208: usize = 8;
+fn aiur_fn_208(
+  inp: [G; IN_208],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_208], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = G::from_u64(256);
+    let __v_34: G = (__v_33 * __v_2);
+    let __v_35: G = G::from_u64(65536);
+    let __v_36: G = (__v_35 * __v_3);
+    let __v_37: G = G::from_u64(16777216);
+    let __v_38: G = (__v_37 * __v_4);
+    let __v_39: G = (__v_36 + __v_38);
+    let __v_40: G = (__v_34 + __v_39);
+    let __v_41: G = (__v_1 + __v_40);
+    let __v_42: G = G::from_u64(256);
+    let __v_43: G = (__v_42 * __v_6);
+    let __v_44: G = G::from_u64(65536);
+    let __v_45: G = (__v_44 * __v_7);
+    let __v_46: G = G::from_u64(16777216);
+    let __v_47: G = (__v_46 * __v_8);
+    let __v_48: G = (__v_45 + __v_47);
+    let __v_49: G = (__v_43 + __v_48);
+    let __v_50: G = (__v_5 + __v_49);
+    let __v_51: G = G::from_u64(256);
+    let __v_52: G = (__v_51 * __v_10);
+    let __v_53: G = G::from_u64(65536);
+    let __v_54: G = (__v_53 * __v_11);
+    let __v_55: G = G::from_u64(16777216);
+    let __v_56: G = (__v_55 * __v_12);
+    let __v_57: G = (__v_54 + __v_56);
+    let __v_58: G = (__v_52 + __v_57);
+    let __v_59: G = (__v_9 + __v_58);
+    let __v_60: G = G::from_u64(256);
+    let __v_61: G = (__v_60 * __v_14);
+    let __v_62: G = G::from_u64(65536);
+    let __v_63: G = (__v_62 * __v_15);
+    let __v_64: G = G::from_u64(16777216);
+    let __v_65: G = (__v_64 * __v_16);
+    let __v_66: G = (__v_63 + __v_65);
+    let __v_67: G = (__v_61 + __v_66);
+    let __v_68: G = (__v_13 + __v_67);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_69 * __v_18);
+    let __v_71: G = G::from_u64(65536);
+    let __v_72: G = (__v_71 * __v_19);
+    let __v_73: G = G::from_u64(16777216);
+    let __v_74: G = (__v_73 * __v_20);
+    let __v_75: G = (__v_72 + __v_74);
+    let __v_76: G = (__v_70 + __v_75);
+    let __v_77: G = (__v_17 + __v_76);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_78 * __v_22);
+    let __v_80: G = G::from_u64(65536);
+    let __v_81: G = (__v_80 * __v_23);
+    let __v_82: G = G::from_u64(16777216);
+    let __v_83: G = (__v_82 * __v_24);
+    let __v_84: G = (__v_81 + __v_83);
+    let __v_85: G = (__v_79 + __v_84);
+    let __v_86: G = (__v_21 + __v_85);
+    let __v_87: G = G::from_u64(256);
+    let __v_88: G = (__v_87 * __v_26);
+    let __v_89: G = G::from_u64(65536);
+    let __v_90: G = (__v_89 * __v_27);
+    let __v_91: G = G::from_u64(16777216);
+    let __v_92: G = (__v_91 * __v_28);
+    let __v_93: G = (__v_90 + __v_92);
+    let __v_94: G = (__v_88 + __v_93);
+    let __v_95: G = (__v_25 + __v_94);
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_96 * __v_30);
+    let __v_98: G = G::from_u64(65536);
+    let __v_99: G = (__v_98 * __v_31);
+    let __v_100: G = G::from_u64(16777216);
+    let __v_101: G = (__v_100 * __v_32);
+    let __v_102: G = (__v_99 + __v_101);
+    let __v_103: G = (__v_97 + __v_102);
+    let __v_104: G = (__v_29 + __v_103);
+    let __ret: [G; OUT_208] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104];
+    if !unconstrained { record.virt += record.function_queries[208].weight(); } record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+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_209], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1, __v_4]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_5]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; 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 { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } 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_10: G = __r_arr[0];
+    let __ret: [G; OUT_209] = [__v_10];
+    if !unconstrained { record.virt += record.function_queries[209].weight(); } record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_210: usize = 1;
+const IN_210: usize = 1;
+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 __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0, __v_3]; 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 { let __r = record.function_queries[207].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; 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 { let __r = record.function_queries[65].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __ret: [G; OUT_210] = [__v_8];
+    if !unconstrained { record.virt += record.function_queries[210].weight(); } record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_211: usize = 4;
+const IN_211: usize = 4;
+const OUT_211: usize = 1;
+fn aiur_fn_211(
+  inp: [G; IN_211],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_211], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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(256);
+    let __v_5: G = (__v_0 * __v_4);
+    let __v_6: G = (__v_5 + __v_1);
+    let __v_7: G = G::from_u64(256);
+    let __v_8: G = (__v_6 * __v_7);
+    let __v_9: G = (__v_8 + __v_2);
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_9 * __v_10);
+    let __v_12: G = (__v_11 + __v_3);
+    let __ret: [G; OUT_211] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[211].weight(); } record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_212: usize = 2;
+const IN_212: usize = 2;
+const OUT_212: usize = 1;
+fn aiur_fn_212(
+  inp: [G; IN_212],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_212], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __v_5: G = __loaded[3];
+    let __v_6: G = __loaded[4];
+    let __v_7: G = __loaded[5];
+    let __v_8: G = __loaded[6];
+    let __v_9: G = __loaded[7];
+    let __v_10: G = __loaded[8];
+    let __v_11: G = __loaded[9];
+    let __v_12: G = __loaded[10];
+    let __v_13: G = __loaded[11];
+    let __v_14: G = __loaded[12];
+    let __v_15: G = __loaded[13];
+    let __v_16: G = __loaded[14];
+    let __v_17: G = __loaded[15];
+    let __v_18: G = __loaded[16];
+    let __v_19: G = __loaded[17];
+    let __v_20: G = __loaded[18];
+    let __v_21: G = __loaded[19];
+    let __v_22: G = __loaded[20];
+    let __v_23: G = __loaded[21];
+    let __v_24: G = __loaded[22];
+    let __v_25: G = __loaded[23];
+    let __v_26: G = __loaded[24];
+    let __v_27: G = __loaded[25];
+    let __v_28: G = __loaded[26];
+    let __v_29: G = __loaded[27];
+    let __v_30: G = __loaded[28];
+    let __v_31: G = __loaded[29];
+    let __v_32: G = __loaded[30];
+    let __v_33: G = __loaded[31];
+    let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_34: G = __loaded[0];
+    let __v_35: G = __loaded[1];
+    let __v_36: G = __loaded[2];
+    let __v_37: G = __loaded[3];
+    let __v_38: G = __loaded[4];
+    let __v_39: G = __loaded[5];
+    let __v_40: G = __loaded[6];
+    let __v_41: G = __loaded[7];
+    let __v_42: G = __loaded[8];
+    let __v_43: G = __loaded[9];
+    let __v_44: G = __loaded[10];
+    let __v_45: G = __loaded[11];
+    let __v_46: G = __loaded[12];
+    let __v_47: G = __loaded[13];
+    let __v_48: G = __loaded[14];
+    let __v_49: G = __loaded[15];
+    let __v_50: G = __loaded[16];
+    let __v_51: G = __loaded[17];
+    let __v_52: G = __loaded[18];
+    let __v_53: G = __loaded[19];
+    let __v_54: G = __loaded[20];
+    let __v_55: G = __loaded[21];
+    let __v_56: G = __loaded[22];
+    let __v_57: G = __loaded[23];
+    let __v_58: G = __loaded[24];
+    let __v_59: G = __loaded[25];
+    let __v_60: G = __loaded[26];
+    let __v_61: G = __loaded[27];
+    let __v_62: G = __loaded[28];
+    let __v_63: G = __loaded[29];
+    let __v_64: G = __loaded[30];
+    let __v_65: G = __loaded[31];
+    let __v_66: G = G::from_u64(256);
+    let __v_67: G = (__v_2 * __v_66);
+    let __v_68: G = (__v_67 + __v_3);
+    let __v_69: G = G::from_u64(256);
+    let __v_70: G = (__v_68 * __v_69);
+    let __v_71: G = (__v_70 + __v_4);
+    let __v_72: G = G::from_u64(256);
+    let __v_73: G = (__v_71 * __v_72);
+    let __v_74: G = (__v_73 + __v_5);
+    let __v_75: G = G::from_u64(256);
+    let __v_76: G = (__v_34 * __v_75);
+    let __v_77: G = (__v_76 + __v_35);
+    let __v_78: G = G::from_u64(256);
+    let __v_79: G = (__v_77 * __v_78);
+    let __v_80: G = (__v_79 + __v_36);
+    let __v_81: G = G::from_u64(256);
+    let __v_82: G = (__v_80 * __v_81);
+    let __v_83: G = (__v_82 + __v_37);
+    let __v_84: G = (__v_74 - __v_83);
+    match __v_84.as_canonical_u64() {
+      0u64 => {
+        let __v_85: G = G::from_u64(256);
+        let __v_86: G = (__v_6 * __v_85);
+        let __v_87: G = (__v_86 + __v_7);
+        let __v_88: G = G::from_u64(256);
+        let __v_89: G = (__v_87 * __v_88);
+        let __v_90: G = (__v_89 + __v_8);
+        let __v_91: G = G::from_u64(256);
+        let __v_92: G = (__v_90 * __v_91);
+        let __v_93: G = (__v_92 + __v_9);
+        let __v_94: G = G::from_u64(256);
+        let __v_95: G = (__v_38 * __v_94);
+        let __v_96: G = (__v_95 + __v_39);
+        let __v_97: G = G::from_u64(256);
+        let __v_98: G = (__v_96 * __v_97);
+        let __v_99: G = (__v_98 + __v_40);
+        let __v_100: G = G::from_u64(256);
+        let __v_101: G = (__v_99 * __v_100);
+        let __v_102: G = (__v_101 + __v_41);
+        let __v_103: G = (__v_93 - __v_102);
+        match __v_103.as_canonical_u64() {
+          0u64 => {
+            let __v_104: G = G::from_u64(256);
+            let __v_105: G = (__v_10 * __v_104);
+            let __v_106: G = (__v_105 + __v_11);
+            let __v_107: G = G::from_u64(256);
+            let __v_108: G = (__v_106 * __v_107);
+            let __v_109: G = (__v_108 + __v_12);
+            let __v_110: G = G::from_u64(256);
+            let __v_111: G = (__v_109 * __v_110);
+            let __v_112: G = (__v_111 + __v_13);
+            let __v_113: G = G::from_u64(256);
+            let __v_114: G = (__v_42 * __v_113);
+            let __v_115: G = (__v_114 + __v_43);
+            let __v_116: G = G::from_u64(256);
+            let __v_117: G = (__v_115 * __v_116);
+            let __v_118: G = (__v_117 + __v_44);
+            let __v_119: G = G::from_u64(256);
+            let __v_120: G = (__v_118 * __v_119);
+            let __v_121: G = (__v_120 + __v_45);
+            let __v_122: G = (__v_112 - __v_121);
+            match __v_122.as_canonical_u64() {
+              0u64 => {
+                let __v_123: G = G::from_u64(256);
+                let __v_124: G = (__v_14 * __v_123);
+                let __v_125: G = (__v_124 + __v_15);
+                let __v_126: G = G::from_u64(256);
+                let __v_127: G = (__v_125 * __v_126);
+                let __v_128: G = (__v_127 + __v_16);
+                let __v_129: G = G::from_u64(256);
+                let __v_130: G = (__v_128 * __v_129);
+                let __v_131: G = (__v_130 + __v_17);
+                let __v_132: G = G::from_u64(256);
+                let __v_133: G = (__v_46 * __v_132);
+                let __v_134: G = (__v_133 + __v_47);
+                let __v_135: G = G::from_u64(256);
+                let __v_136: G = (__v_134 * __v_135);
+                let __v_137: G = (__v_136 + __v_48);
+                let __v_138: G = G::from_u64(256);
+                let __v_139: G = (__v_137 * __v_138);
+                let __v_140: G = (__v_139 + __v_49);
+                let __v_141: G = (__v_131 - __v_140);
+                match __v_141.as_canonical_u64() {
+                  0u64 => {
+                    let __v_142: G = G::from_u64(256);
+                    let __v_143: G = (__v_18 * __v_142);
+                    let __v_144: G = (__v_143 + __v_19);
+                    let __v_145: G = G::from_u64(256);
+                    let __v_146: G = (__v_144 * __v_145);
+                    let __v_147: G = (__v_146 + __v_20);
+                    let __v_148: G = G::from_u64(256);
+                    let __v_149: G = (__v_147 * __v_148);
+                    let __v_150: G = (__v_149 + __v_21);
+                    let __v_151: G = G::from_u64(256);
+                    let __v_152: G = (__v_50 * __v_151);
+                    let __v_153: G = (__v_152 + __v_51);
+                    let __v_154: G = G::from_u64(256);
+                    let __v_155: G = (__v_153 * __v_154);
+                    let __v_156: G = (__v_155 + __v_52);
+                    let __v_157: G = G::from_u64(256);
+                    let __v_158: G = (__v_156 * __v_157);
+                    let __v_159: G = (__v_158 + __v_53);
+                    let __v_160: G = (__v_150 - __v_159);
+                    match __v_160.as_canonical_u64() {
+                      0u64 => {
+                        let __v_161: G = G::from_u64(256);
+                        let __v_162: G = (__v_22 * __v_161);
+                        let __v_163: G = (__v_162 + __v_23);
+                        let __v_164: G = G::from_u64(256);
+                        let __v_165: G = (__v_163 * __v_164);
+                        let __v_166: G = (__v_165 + __v_24);
+                        let __v_167: G = G::from_u64(256);
+                        let __v_168: G = (__v_166 * __v_167);
+                        let __v_169: G = (__v_168 + __v_25);
+                        let __v_170: G = G::from_u64(256);
+                        let __v_171: G = (__v_54 * __v_170);
+                        let __v_172: G = (__v_171 + __v_55);
+                        let __v_173: G = G::from_u64(256);
+                        let __v_174: G = (__v_172 * __v_173);
+                        let __v_175: G = (__v_174 + __v_56);
+                        let __v_176: G = G::from_u64(256);
+                        let __v_177: G = (__v_175 * __v_176);
+                        let __v_178: G = (__v_177 + __v_57);
+                        let __v_179: G = (__v_169 - __v_178);
+                        match __v_179.as_canonical_u64() {
+                          0u64 => {
+                            let __v_180: G = G::from_u64(256);
+                            let __v_181: G = (__v_26 * __v_180);
+                            let __v_182: G = (__v_181 + __v_27);
+                            let __v_183: G = G::from_u64(256);
+                            let __v_184: G = (__v_182 * __v_183);
+                            let __v_185: G = (__v_184 + __v_28);
+                            let __v_186: G = G::from_u64(256);
+                            let __v_187: G = (__v_185 * __v_186);
+                            let __v_188: G = (__v_187 + __v_29);
+                            let __v_189: G = G::from_u64(256);
+                            let __v_190: G = (__v_58 * __v_189);
+                            let __v_191: G = (__v_190 + __v_59);
+                            let __v_192: G = G::from_u64(256);
+                            let __v_193: G = (__v_191 * __v_192);
+                            let __v_194: G = (__v_193 + __v_60);
+                            let __v_195: G = G::from_u64(256);
+                            let __v_196: G = (__v_194 * __v_195);
+                            let __v_197: G = (__v_196 + __v_61);
+                            let __v_198: G = (__v_188 - __v_197);
+                            match __v_198.as_canonical_u64() {
+                              0u64 => {
+                                let __v_199: G = G::from_u64(256);
+                                let __v_200: G = (__v_30 * __v_199);
+                                let __v_201: G = (__v_200 + __v_31);
+                                let __v_202: G = G::from_u64(256);
+                                let __v_203: G = (__v_201 * __v_202);
+                                let __v_204: G = (__v_203 + __v_32);
+                                let __v_205: G = G::from_u64(256);
+                                let __v_206: G = (__v_204 * __v_205);
+                                let __v_207: G = (__v_206 + __v_33);
+                                let __v_208: G = G::from_u64(256);
+                                let __v_209: G = (__v_62 * __v_208);
+                                let __v_210: G = (__v_209 + __v_63);
+                                let __v_211: G = G::from_u64(256);
+                                let __v_212: G = (__v_210 * __v_211);
+                                let __v_213: G = (__v_212 + __v_64);
+                                let __v_214: G = G::from_u64(256);
+                                let __v_215: G = (__v_213 * __v_214);
+                                let __v_216: G = (__v_215 + __v_65);
+                                let __v_217: G = (__v_207 - __v_216);
+                                match __v_217.as_canonical_u64() {
+                                  0u64 => {
+                                    let __v_218: G = G::from_u64(1);
+                                    let __ret: [G; OUT_212] = [__v_218];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_218: G = { let __a_val = __v_207.as_canonical_u64(); let __b_val = __v_216.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_218.as_canonical_u64() {
+                                      1u64 => {
+                                        let __v_219: G = G::from_u64(0);
+                                        let __ret: [G; OUT_212] = [__v_219];
+                                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                      _ => {
+                                        let __v_219: G = G::from_u64(2);
+                                        let __ret: [G; OUT_212] = [__v_219];
+                                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                        return Ok(__ret);
+                                      },
+                                    }
+                                  },
+                                }
+                              },
+                              _ => {
+                                let __v_199: G = { let __a_val = __v_188.as_canonical_u64(); let __b_val = __v_197.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_199.as_canonical_u64() {
+                                  1u64 => {
+                                    let __v_200: G = G::from_u64(0);
+                                    let __ret: [G; OUT_212] = [__v_200];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                  _ => {
+                                    let __v_200: G = G::from_u64(2);
+                                    let __ret: [G; OUT_212] = [__v_200];
+                                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                    return Ok(__ret);
+                                  },
+                                }
+                              },
+                            }
+                          },
+                          _ => {
+                            let __v_180: G = { let __a_val = __v_169.as_canonical_u64(); let __b_val = __v_178.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_180.as_canonical_u64() {
+                              1u64 => {
+                                let __v_181: G = G::from_u64(0);
+                                let __ret: [G; OUT_212] = [__v_181];
+                                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                              _ => {
+                                let __v_181: G = G::from_u64(2);
+                                let __ret: [G; OUT_212] = [__v_181];
+                                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                                return Ok(__ret);
+                              },
+                            }
+                          },
+                        }
+                      },
+                      _ => {
+                        let __v_161: G = { let __a_val = __v_150.as_canonical_u64(); let __b_val = __v_159.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_161.as_canonical_u64() {
+                          1u64 => {
+                            let __v_162: G = G::from_u64(0);
+                            let __ret: [G; OUT_212] = [__v_162];
+                            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                          _ => {
+                            let __v_162: G = G::from_u64(2);
+                            let __ret: [G; OUT_212] = [__v_162];
+                            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
+                        }
+                      },
+                    }
+                  },
+                  _ => {
+                    let __v_142: G = { let __a_val = __v_131.as_canonical_u64(); let __b_val = __v_140.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_142.as_canonical_u64() {
+                      1u64 => {
+                        let __v_143: G = G::from_u64(0);
+                        let __ret: [G; OUT_212] = [__v_143];
+                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                      _ => {
+                        let __v_143: G = G::from_u64(2);
+                        let __ret: [G; OUT_212] = [__v_143];
+                        if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                        return Ok(__ret);
+                      },
+                    }
+                  },
+                }
+              },
+              _ => {
+                let __v_123: G = { let __a_val = __v_112.as_canonical_u64(); let __b_val = __v_121.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_123.as_canonical_u64() {
+                  1u64 => {
+                    let __v_124: G = G::from_u64(0);
+                    let __ret: [G; OUT_212] = [__v_124];
+                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    let __v_124: G = G::from_u64(2);
+                    let __ret: [G; OUT_212] = [__v_124];
+                    if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
             }
-            let __v_134: G = (__v_50 * __v_126);
-            let __v_135: G = G::from_u64(0);
-            let __v_136: G = (__v_135 - __v_51);
-            let __v_137: G = (__v_136 * __v_126);
-            let __v_138: G = G::from_u64(0);
-            let __v_139: G = G::from_u64(0);
-            let __v_140: G = G::from_u64(0);
-            let __v_141: G = G::from_u64(0);
-            let __v_142: G = G::from_u64(0);
-            let __v_143: G = G::from_u64(0);
-            let __v_144: G = G::from_u64(0);
-            let __v_145: G = G::from_u64(0);
-            let __v_146: G = G::from_u64(0);
-            let __v_147: G = G::from_u64(0);
-            let __v_148: G = G::from_u64(0);
-            let __v_149: G = G::from_u64(0);
-            let __v_150: G = G::from_u64(0);
-            let __v_151: G = G::from_u64(0);
-            let __v_152: G = G::from_u64(0);
-            let __v_153: G = G::from_u64(0);
-            let __v_154: G = G::from_u64(1);
-            let __v_155: G = G::from_u64(1);
-            let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } };
-            let __v_165: G = __r_arr[0];
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } };
-            let __v_166: G = __r_arr[0];
-            let __v_167: G = (__v_165 * __v_166);
-            let __v_168: G = g_inverse_value(__v_167);
-            let __v_169: G = (__v_167 * __v_168);
-            let __v_170: G = G::from_u64(1);
-            let __v_171: G = (__v_169 - __v_170);
-            let __v_172: G = (__v_167 * __v_171);
-            let __v_173: G = G::from_u64(0);
-            if (__v_172 != __v_173) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: None });
+          },
+          _ => {
+            let __v_104: G = { let __a_val = __v_93.as_canonical_u64(); let __b_val = __v_102.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_104.as_canonical_u64() {
+              1u64 => {
+                let __v_105: G = G::from_u64(0);
+                let __ret: [G; OUT_212] = [__v_105];
+                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_105: G = G::from_u64(2);
+                let __ret: [G; OUT_212] = [__v_105];
+                if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
             }
-            let __v_174: G = (__v_168 * __v_171);
-            let __v_175: G = G::from_u64(0);
-            if (__v_174 != __v_175) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_174.as_canonical_u64(), rhs: __v_175.as_canonical_u64(), msg: None });
+          },
+        }
+      },
+      _ => {
+        let __v_85: G = { let __a_val = __v_74.as_canonical_u64(); let __b_val = __v_83.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_85.as_canonical_u64() {
+          1u64 => {
+            let __v_86: G = G::from_u64(0);
+            let __ret: [G; OUT_212] = [__v_86];
+            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_86: G = G::from_u64(2);
+            let __ret: [G; OUT_212] = [__v_86];
+            if !unconstrained { record.virt += record.function_queries[212].weight(); } record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_213: usize = 1;
+const IN_213: usize = 1;
+const OUT_213: usize = 0;
+fn aiur_fn_213(
+  inp: [G; IN_213],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_213], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __ret: [G; OUT_213] = [];
+        if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_213] = [];
+            if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_2, __v_5]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __v_8: G = G::from_u64(0);
+            if (__v_7 != __v_8) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: tree leaves are not strictly sorted".to_string()) });
             }
-            let __v_176: G = G::from_u64(0);
-            let __v_177: G = G::from_u64(0);
-            let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } };
-            let __v_178: G = __r_arr[0];
-            let __v_179: G = __r_arr[1];
-            let __v_180: G = G::from_u64(0);
-            let __v_181: G = G::from_u64(0);
-            let __v_182: G = G::from_u64(0);
-            let __v_183: G = G::from_u64(0);
-            let __v_184: G = G::from_u64(0);
-            let __v_185: G = G::from_u64(0);
-            let __v_186: G = G::from_u64(0);
-            let __v_187: G = G::from_u64(0);
-            let __v_188: G = (__v_30 - __v_10);
-            let __v_189: G = (__v_186 - __v_184);
-            let __v_190: G = G::from_u64(0);
-            let __v_191: G = (__v_188 * __v_168);
-            let __v_192: G = G::from_u64(7);
-            let __v_193: G = (__v_189 * __v_190);
-            let __v_194: G = (__v_192 * __v_193);
-            let __v_195: G = (__v_191 + __v_194);
-            let __v_196: G = (__v_188 * __v_190);
-            let __v_197: G = (__v_189 * __v_168);
-            let __v_198: G = (__v_196 + __v_197);
-            let __v_199: G = (__v_114 * __v_195);
-            let __v_200: G = G::from_u64(7);
-            let __v_201: G = (__v_117 * __v_198);
-            let __v_202: G = (__v_200 * __v_201);
-            let __v_203: G = (__v_199 + __v_202);
-            let __v_204: G = (__v_114 * __v_198);
-            let __v_205: G = (__v_117 * __v_195);
-            let __v_206: G = (__v_204 + __v_205);
-            let __v_207: G = (__v_31 - __v_11);
-            let __v_208: G = (__v_187 - __v_185);
-            let __v_209: G = G::from_u64(0);
-            let __v_210: G = (__v_207 * __v_168);
-            let __v_211: G = G::from_u64(7);
-            let __v_212: G = (__v_208 * __v_209);
-            let __v_213: G = (__v_211 * __v_212);
-            let __v_214: G = (__v_210 + __v_213);
-            let __v_215: G = (__v_207 * __v_209);
-            let __v_216: G = (__v_208 * __v_168);
-            let __v_217: G = (__v_215 + __v_216);
-            let __v_218: G = (__v_114 * __v_214);
-            let __v_219: G = G::from_u64(7);
-            let __v_220: G = (__v_117 * __v_217);
-            let __v_221: G = (__v_219 * __v_220);
-            let __v_222: G = (__v_218 + __v_221);
-            let __v_223: G = (__v_114 * __v_217);
-            let __v_224: G = (__v_117 * __v_214);
-            let __v_225: G = (__v_223 + __v_224);
-            let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-            let __v_226: G = __loaded[0];
-            let __v_227: G = __loaded[1];
-            let __v_228: G = __loaded[2];
-            let __v_229: G = __loaded[3];
-            let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() {
-  1u64 => {
-    let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_230]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-    let __v_231: G = __r_arr[0];
-    let __v_232: G = __r_arr[1];
-    let __v_233: G = G::from_u64(0);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-    let __v_234: G = __r_arr[0];
-    let __v_235: G = __r_arr[1];
-    let __v_236: G = (__v_231 - __v_234);
-    let __v_237: G = (__v_232 - __v_235);
-    let __v_238: G = (__v_236 + __v_203);
-    let __v_239: G = (__v_237 + __v_206);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-    let __v_240: G = __r_arr[0];
-    let __v_241: G = __r_arr[1];
-    let __v_242: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_41, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-    let __v_243: G = __r_arr[0];
-    let __v_244: G = __r_arr[1];
-    let __v_245: G = G::from_u64(1);
-    let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_39, __v_245]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } };
-    let __v_246: G = __r_arr[0];
-    let __v_247: G = __r_arr[1];
-    let __v_248: G = (__v_243 - __v_246);
-    let __v_249: G = (__v_244 - __v_247);
-    let __v_250: G = (__v_248 + __v_222);
-    let __v_251: G = (__v_249 + __v_225);
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } };
-    let __v_252: G = __r_arr[0];
-    let __v_253: G = __r_arr[1];
-    break '__mc_1 [__v_252, __v_253];
-  },
-  0u64 => {
-    let __v_230: G = G::from_u64(0);
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_231: G = __r_arr[0];
-    let __v_232: G = G::from_u64(0);
-    let __v_233: G = G::from_u64(1);
-    let __v_234: G = G::from_u64(0);
-    let __v_235: G = G::from_u64(0);
-    let __v_236: G = G::from_u64(0);
-    let __v_237: G = G::from_u64(0);
-    let __v_238: G = G::from_u64(0);
-    let __v_239: G = G::from_u64(0);
-    let __v_240: G = G::from_u64(0);
-    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } };
-    let __v_241: G = __r_arr[0];
-    let __v_242: G = __r_arr[1];
-    break '__mc_1 [__v_241, __v_242];
-  },
-  _ => {
-    return Err(ExecError::MatchNoCase(__v_226.as_canonical_u64()));
-  },
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3]; 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 { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_213] = [];
+            if !unconstrained { record.virt += record.function_queries[213].weight(); } record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_214: usize = 1;
+const IN_214: usize = 1;
+const OUT_214: usize = 2;
+fn aiur_fn_214(
+  inp: [G; IN_214],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_214], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_214] = [__v_9, __v_4];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_214] = [__v_5, __v_2];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      2u64 => {
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_2]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_4]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3, __v_5]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+        let __ret: [G; OUT_214] = [__v_7, __v_6];
+        if !unconstrained { record.virt += record.function_queries[214].weight(); } record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
 }
- };
-            let __v_230: G = __mc_out___mc_1[0];
-            let __v_231: G = __mc_out___mc_1[1];
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_232: G = __r_arr[0];
-            let __v_233: G = G::from_u64(0);
-            let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_232, __v_233]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } };
-            let __v_234: G = __r_arr[0];
-            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_234]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } };
-            let __v_235: G = __r_arr[0];
-            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } };
-            let __v_236: G = __r_arr[0];
-            let __v_237: G = __r_arr[1];
-            let __v_238: G = G::from_u64(1);
-            let __v_239: G = G::from_u64(0);
-            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } };
-            let __v_240: G = __r_arr[0];
-            let __v_241: G = __r_arr[1];
-            let __v_242: G = (__v_230 * __v_134);
-            let __v_243: G = G::from_u64(7);
-            let __v_244: G = (__v_231 * __v_137);
-            let __v_245: G = (__v_243 * __v_244);
-            let __v_246: G = (__v_242 + __v_245);
-            let __v_247: G = (__v_230 * __v_137);
-            let __v_248: G = (__v_231 * __v_134);
-            let __v_249: G = (__v_247 + __v_248);
-            let __v_250: G = G::from_u64(32);
-            let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) };
-            let __v_252: G = G::from_u64(1);
-            if (__v_251 != __v_252) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None });
+
+const INPUT_SIZE_215: usize = 1;
+const IN_215: usize = 1;
+const OUT_215: usize = 1;
+fn aiur_fn_215(
+  inp: [G; IN_215],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_215], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_215] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2]; 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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3]; 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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_215] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[215].weight(); } record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_216: usize = 1;
+const IN_216: usize = 1;
+const OUT_216: usize = 1;
+fn aiur_fn_216(
+  inp: [G; IN_216],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_216], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __v_5: G = G::from_u64(1);
+        let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_216] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __v_10: G = G::from_u64(0);
+            let __v_11: G = G::from_u64(0);
+            let __v_12: G = G::from_u64(0);
+            let __v_13: G = G::from_u64(0);
+            let __v_14: G = G::from_u64(0);
+            let __v_15: G = G::from_u64(0);
+            let __v_16: G = G::from_u64(0);
+            let __v_17: G = G::from_u64(0);
+            let __v_18: G = G::from_u64(0);
+            let __v_19: G = G::from_u64(0);
+            let __v_20: G = G::from_u64(0);
+            let __v_21: G = G::from_u64(0);
+            let __v_22: G = G::from_u64(0);
+            let __v_23: G = G::from_u64(0);
+            let __v_24: G = G::from_u64(0);
+            let __v_25: G = G::from_u64(0);
+            let __v_26: G = G::from_u64(0);
+            let __v_27: G = G::from_u64(0);
+            let __v_28: G = G::from_u64(0);
+            let __v_29: G = G::from_u64(0);
+            let __v_30: G = G::from_u64(0);
+            let __v_31: G = G::from_u64(0);
+            let __v_32: G = G::from_u64(0);
+            let __v_33: G = G::from_u64(0);
+            let __v_34: G = G::from_u64(0);
+            let __v_35: G = G::from_u64(0);
+            let __v_36: G = G::from_u64(0);
+            let __v_37: G = G::from_u64(0);
+            let __v_38: G = G::from_u64(0);
+            let __v_39: G = { 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_40: G = G::from_u64(0);
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_39]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_41: G = __r_arr[0];
+            let __v_42: G = G::from_u64(1);
+            let __v_43: G = G::from_u64(1);
+            let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_216] = [__v_45];
+            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_7: G = G::from_u64(0);
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_5]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_6]; 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 { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+            let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+            let __ret: [G; OUT_216] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[216].weight(); } record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_217: usize = 1;
+const IN_217: usize = 1;
+const OUT_217: usize = 1;
+fn aiur_fn_217(
+  inp: [G; IN_217],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_217], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        match __v_4.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_217] = [__v_2];
+            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; 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 { let __r = record.function_queries[216].replay_at(__i); record.virt += __r; } 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_7: G = __r_arr[0];
+            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_7]; 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 { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            let __ret: [G; OUT_217] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[217].weight(); } record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_218: usize = 1;
+const IN_218: usize = 1;
+const OUT_218: usize = 1;
+fn aiur_fn_218(
+  inp: [G; IN_218],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_218], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0]; 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 { let __r = record.function_queries[215].replay_at(__i); record.virt += __r; } 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_1: G = __r_arr[0];
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_1]; 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 { let __r = record.function_queries[217].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __ret: [G; OUT_218] = [__v_2];
+    if !unconstrained { record.virt += record.function_queries[218].weight(); } record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_219: usize = 1;
+const IN_219: usize = 1;
+const OUT_219: usize = 1;
+fn aiur_fn_219(
+  inp: [G; IN_219],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_219], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    let __v_11: G = __loaded[10];
+    let __v_12: G = __loaded[11];
+    let __v_13: G = __loaded[12];
+    let __v_14: G = __loaded[13];
+    let __v_15: G = __loaded[14];
+    let __v_16: G = __loaded[15];
+    let __v_17: G = __loaded[16];
+    let __v_18: G = __loaded[17];
+    let __v_19: G = __loaded[18];
+    let __v_20: G = __loaded[19];
+    let __v_21: G = __loaded[20];
+    let __v_22: G = __loaded[21];
+    let __v_23: G = __loaded[22];
+    let __v_24: G = __loaded[23];
+    let __v_25: G = __loaded[24];
+    let __v_26: G = __loaded[25];
+    let __v_27: G = __loaded[26];
+    let __v_28: G = __loaded[27];
+    let __v_29: G = __loaded[28];
+    let __v_30: G = __loaded[29];
+    let __v_31: G = __loaded[30];
+    let __v_32: G = __loaded[31];
+    let __v_33: G = G::from_u64(5);
+    let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_34: G = __io_pair.0;
+    let __v_35: G = __io_pair.1;
+    let __v_36: G = G::from_u64(5);
+    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_77] = { let __args: [G; IN_77] = [__v_37]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_39]; 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 { let __r = record.function_queries[214].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_40]; 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 { let __r = record.function_queries[213].replay_at(__i); record.virt += __r; } 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] = [__v_40]; 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 { let __r = record.function_queries[218].replay_at(__i); record.virt += __r; } 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_42: G = __r_arr[0];
+    let __v_43: G = G::from_u64(226);
+    if (__v_38 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("join: tree has the wrong Ixon tag".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_44: G = __loaded[0];
+    let __v_45: G = __loaded[1];
+    let __v_46: G = __loaded[2];
+    let __v_47: G = G::from_u64(1);
+    let __v_48: G = G::from_u64(1);
+    if (__v_44 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("join: trailing bytes after AssumptionTree".to_string()) });
+    }
+    if (__v_45 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("join: trailing bytes after AssumptionTree".to_string()) });
+    }
+    if (__v_46 != __v_48) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("join: trailing bytes after AssumptionTree".to_string()) });
+    }
+    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_40]; 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 { let __r = record.function_queries[250].replay_at(__i); record.virt += __r; } 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_49: G = __r_arr[0];
+    let __v_50: G = G::from_u64(0);
+    if (__v_49 != __v_50) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("join: a present tree must contain at least one leaf".to_string()) });
+    }
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_51: G = __r_arr[0];
+    let __v_52: G = G::from_u64(1);
+    if (__v_51 != __v_52) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("join: tree leaves do not reproduce the canonical root".to_string()) });
+    }
+    let __ret: [G; OUT_219] = [__v_40];
+    if !unconstrained { record.virt += record.function_queries[219].weight(); } record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_220: usize = 2;
+const IN_220: usize = 2;
+const OUT_220: usize = 1;
+fn aiur_fn_220(
+  inp: [G; IN_220],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_220], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    match __v_0.as_canonical_u64() {
+      1u64 => {
+        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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_220] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+        let __ret: [G; OUT_220] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[220].weight(); } record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_221: usize = 2;
+const IN_221: usize = 2;
+const OUT_221: usize = 0;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __ret: [G; OUT_221] = [];
+            if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_9: G = G::from_u64(1);
+            if (__v_8 != __v_9) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: set element mismatch".to_string()) });
             }
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_235]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-            let __v_253: G = __r_arr[0];
-            let __v_254: G = (__v_253 - __v_29);
-            let __v_255: G = G::from_bool((__v_254 == G::ZERO));
-            let __v_256: G = G::from_u64(1);
-            if (__v_255 != __v_256) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64(), msg: None });
+            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_4, __v_7]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_221] = [];
+            if !unconstrained { record.virt += record.function_queries[221].weight(); } record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_222: usize = 3;
+const IN_222: usize = 3;
+const OUT_222: usize = 0;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_6: G = __loaded[0];
+    let __v_7: G = __loaded[1];
+    let __v_8: G = __loaded[2];
+    match __v_3.as_canonical_u64() {
+      1u64 => {
+        let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+        if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        match __v_6.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0, __v_2]; 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 { let __r = record.function_queries[221].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+            if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_4, __v_7]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_12: G = __r_arr[0];
+                match __v_12.as_canonical_u64() {
+                  0u64 => {
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("join: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  1u64 => {
+                    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("join: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_8, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                  _ => {
+                    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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                    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("join: subject union mismatch".to_string()) });
+                    }
+                    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_8, __v_11]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_222] = [];
+                    if !unconstrained { record.virt += record.function_queries[222].weight(); } record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                    return Ok(__ret);
+                  },
+                }
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
             }
-            let __v_257: G = (__v_246 - __v_240);
-            let __v_258: G = G::from_bool((__v_257 == G::ZERO));
-            let __v_259: G = (__v_249 - __v_241);
-            let __v_260: G = G::from_bool((__v_259 == G::ZERO));
-            let __v_261: G = (__v_258 * __v_260);
-            let __v_262: G = G::from_u64(1);
-            if (__v_261 != __v_262) {
-              return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_262.as_canonical_u64(), msg: None });
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_223: usize = 2;
+const IN_223: usize = 2;
+const OUT_223: usize = 4;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_6: G = __loaded[1];
+    let __v_7: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(0);
+            let __v_9: G = G::from_u64(0);
+            let __ret: [G; OUT_223] = [__v_8, __v_9, __v_9, __v_9];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_223] = [__v_8, __v_6, __v_0, __v_7];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      0u64 => {
+        match __v_5.as_canonical_u64() {
+          1u64 => {
+            let __v_8: G = G::from_u64(1);
+            let __ret: [G; OUT_223] = [__v_8, __v_3, __v_4, __v_1];
+            if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          0u64 => {
+            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_6]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+            match __v_8.as_canonical_u64() {
+              0u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_3, __v_4, __v_1];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              1u64 => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_3, __v_4, __v_7];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                let __v_9: G = G::from_u64(1);
+                let __ret: [G; OUT_223] = [__v_9, __v_6, __v_0, __v_7];
+                if !unconstrained { record.virt += record.function_queries[223].weight(); } record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
             }
-            let __v_263: G = G::from_u64(1);
-            let __v_264: G = (__v_9 + __v_263);
-            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-            let __v_265: G = __r_arr[0];
-            let __ret: [G; OUT_180] = [__v_265];
-            if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_224: usize = 2;
+const IN_224: usize = 2;
+const OUT_224: usize = 2;
+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 __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_224] = [__v_5, __v_1];
+        if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_3, __v_0]; 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 { let __r = record.function_queries[212].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_4]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
+            let __v_7: G = __r_arr[1];
+            let __ret: [G; OUT_224] = [__v_6, __v_7];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          1u64 => {
+            let __v_6: G = G::from_u64(1);
+            let __ret: [G; OUT_224] = [__v_6, __v_4];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            let __v_6: G = G::from_u64(0);
+            let __ret: [G; OUT_224] = [__v_6, __v_1];
+            if !unconstrained { record.virt += record.function_queries[224].weight(); } record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_225: usize = 4;
+const IN_225: usize = 4;
+const OUT_225: usize = 0;
+fn aiur_fn_225(
+  inp: [G; IN_225],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_225], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    match __v_4.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        if (__v_8 != __v_11) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output has an extra assumption".to_string()) });
+        }
+        if (__v_9 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output has an extra assumption".to_string()) });
+        }
+        if (__v_10 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output has an extra assumption".to_string()) });
+        }
+        let __ret: [G; OUT_225] = [];
+        if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_2]; 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 { let __r = record.function_queries[224].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        let __v_9: G = __r_arr[1];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_7, __v_9, __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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_225] = [];
+            if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
+          _ => {
+            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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+            let __v_10: G = __loaded[0];
+            let __v_11: G = __loaded[1];
+            let __v_12: G = __loaded[2];
+            match __v_10.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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];
+                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("join: outstanding assumption mismatch".to_string()) });
+                }
+                let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_7, __v_9, __v_12]; 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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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 __ret: [G; OUT_225] = [];
+                if !unconstrained { record.virt += record.function_queries[225].weight(); } record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+              },
+            }
+          },
         }
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_226: usize = 3;
+const IN_226: usize = 3;
+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_226], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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_226] = [__v_0, __v_2];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = __r_arr[1];
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
+  0u64 => {
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_5, __v_0]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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];
+    break '__mc_0 [__v_7];
+  },
+  _ => {
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_5]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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];
+    break '__mc_0 [__v_7];
+  },
+}
+ };
+        let __v_7: G = __mc_out___mc_0[0];
+        let __v_8: G = G::from_u64(2);
+        let __v_9: G = if unconstrained { Bytes2::less_than(&__v_3, &__v_8) } else { bytes2_less_than_value(__v_3, __v_8, record) };
+        let __v_10: G = G::from_u64(1);
+        if (__v_9 != __v_10) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: path side must be 0 or 1".to_string()) });
+        }
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = (__v_1 - __v_11);
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_12, __v_6]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
+        let __v_14: G = __r_arr[1];
+        let __ret: [G; OUT_226] = [__v_13, __v_14];
+        if !unconstrained { record.virt += record.function_queries[226].weight(); } record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_181: usize = 3;
-const IN_181: usize = 3;
-const OUT_181: usize = 2;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_227: usize = 2;
+const IN_227: usize = 2;
+const OUT_227: usize = 1;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_181], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_2: G = G::from_u64(6);
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
@@ -17145,71 +21922,601 @@ fn aiur_fn_181(
     let __v_10: G = __loaded[7];
     let __v_11: G = __loaded[8];
     let __v_12: G = __loaded[9];
-    match __v_3.as_canonical_u64() {
-      1u64 => {
-        let __v_13: G = G::from_u64(0);
-        let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_181] = [__v_13, __v_14];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_13: G = __loaded[10];
+    let __v_14: G = __loaded[11];
+    let __v_15: G = __loaded[12];
+    let __v_16: G = __loaded[13];
+    let __v_17: G = __loaded[14];
+    let __v_18: G = __loaded[15];
+    let __v_19: G = __loaded[16];
+    let __v_20: G = __loaded[17];
+    let __v_21: G = __loaded[18];
+    let __v_22: G = __loaded[19];
+    let __v_23: G = __loaded[20];
+    let __v_24: G = __loaded[21];
+    let __v_25: G = __loaded[22];
+    let __v_26: G = __loaded[23];
+    let __v_27: G = __loaded[24];
+    let __v_28: G = __loaded[25];
+    let __v_29: G = __loaded[26];
+    let __v_30: G = __loaded[27];
+    let __v_31: G = __loaded[28];
+    let __v_32: G = __loaded[29];
+    let __v_33: G = __loaded[30];
+    let __v_34: G = __loaded[31];
+    let __io_pair: (G, G) = { let __key: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __info = io_buffer.get_info(__v_2, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_35: G = __io_pair.0;
+    let __v_36: G = __io_pair.1;
+    let __v_37: G = G::from_u64(6);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; 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_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = G::from_u64(2);
+    let __v_42: G = if unconstrained { Bytes2::less_than(&__v_39, &__v_41) } else { bytes2_less_than_value(__v_39, __v_41, record) };
+    let __v_43: G = G::from_u64(1);
+    if (__v_42 != __v_43) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("structural join: discharge choice must be 0 or 1".to_string()) });
+    }
+    match __v_39.as_canonical_u64() {
+      0u64 => {
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_44: G = __loaded[0];
+        let __v_45: G = __loaded[1];
+        let __v_46: G = __loaded[2];
+        let __v_47: G = G::from_u64(1);
+        let __v_48: G = G::from_u64(1);
+        if (__v_44 != __v_47) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("structural join: carried choice has trailing bytes".to_string()) });
+        }
+        if (__v_45 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("structural join: carried choice has trailing bytes".to_string()) });
+        }
+        if (__v_46 != __v_48) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("structural join: carried choice has trailing bytes".to_string()) });
+        }
+        let __v_49: G = G::from_u64(0);
+        let __ret: [G; OUT_227] = [__v_49];
+        if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; 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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+        let __v_45: G = __r_arr[1];
+        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0]; 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 { let __r = record.function_queries[210].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+        let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_46, __v_44, __v_45]; 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 { let __r = record.function_queries[226].replay_at(__i); record.virt += __r; } 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_47: G = __r_arr[0];
+        let __v_48: G = __r_arr[1];
+        let __v_49: G = G::from_u64(65);
+        let __v_50: G = if unconstrained { Bytes2::less_than(&__v_44, &__v_49) } else { bytes2_less_than_value(__v_44, __v_49, record) };
+        let __v_51: G = G::from_u64(1);
+        if (__v_50 != __v_51) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("structural join: Merkle path exceeds 64 steps".to_string()) });
+        }
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_52: G = __loaded[0];
+        let __v_53: G = __loaded[1];
+        let __v_54: G = __loaded[2];
+        let __v_55: G = G::from_u64(1);
+        let __v_56: G = G::from_u64(1);
+        if (__v_52 != __v_55) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("structural join: trailing bytes after Merkle path".to_string()) });
+        }
+        if (__v_53 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("structural join: trailing bytes after Merkle path".to_string()) });
+        }
+        if (__v_54 != __v_56) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("structural join: trailing bytes after Merkle path".to_string()) });
+        }
+        let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+        let __v_57: G = __r_arr[0];
+        let __v_58: G = G::from_u64(1);
+        if (__v_57 != __v_58) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: Some("structural join: assumption path does not reach subject root".to_string()) });
+        }
+        let __v_59: G = G::from_u64(1);
+        let __ret: [G; OUT_227] = [__v_59];
+        if !unconstrained { record.virt += record.function_queries[227].weight(); } record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
+    }
+  })
+}
+
+const INPUT_SIZE_228: usize = 4;
+const IN_228: usize = 4;
+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_228], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __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_223] = { let __args: [G; IN_223] = [__v_0, __v_1]; 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 { let __r = record.function_queries[223].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
+    let __v_5: G = __r_arr[1];
+    let __v_6: G = __r_arr[2];
+    let __v_7: G = __r_arr[3];
+    match __v_4.as_canonical_u64() {
       0u64 => {
-        let __v_13: G = G::from_u64(256);
-        let __v_14: G = (__v_13 * __v_5);
-        let __v_15: G = G::from_u64(65536);
-        let __v_16: G = (__v_15 * __v_6);
-        let __v_17: G = G::from_u64(16777216);
-        let __v_18: G = (__v_17 * __v_7);
-        let __v_19: G = G::from_u64(4294967296);
-        let __v_20: G = (__v_19 * __v_8);
-        let __v_21: G = G::from_u64(1099511627776);
-        let __v_22: G = (__v_21 * __v_9);
-        let __v_23: G = G::from_u64(281474976710656);
-        let __v_24: G = (__v_23 * __v_10);
-        let __v_25: G = G::from_u64(72057594037927936);
-        let __v_26: G = (__v_25 * __v_11);
-        let __v_27: G = (__v_24 + __v_26);
-        let __v_28: G = (__v_22 + __v_27);
-        let __v_29: G = (__v_20 + __v_28);
-        let __v_30: G = (__v_18 + __v_29);
-        let __v_31: G = (__v_16 + __v_30);
-        let __v_32: G = (__v_14 + __v_31);
-        let __v_33: G = (__v_4 + __v_32);
-        let __v_34: G = G::from_u64(0);
-        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
-        let __v_35: G = __r_arr[0];
-        let __v_36: G = __r_arr[1];
-        let __v_37: G = (__v_0 * __v_35);
-        let __v_38: G = G::from_u64(7);
-        let __v_39: G = (__v_1 * __v_36);
-        let __v_40: G = (__v_38 * __v_39);
-        let __v_41: G = (__v_37 + __v_40);
-        let __v_42: G = (__v_0 * __v_36);
-        let __v_43: G = (__v_1 * __v_35);
-        let __v_44: G = (__v_42 + __v_43);
-        let __v_45: G = (__v_33 + __v_41);
-        let __v_46: G = (__v_34 + __v_44);
-        let __ret: [G; OUT_181] = [__v_45, __v_46];
-        if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_8: G = __loaded[0];
+        let __v_9: G = __loaded[1];
+        let __v_10: G = __loaded[2];
+        let __v_11: G = G::from_u64(1);
+        let __v_12: G = G::from_u64(1);
+        if (__v_8 != __v_11) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output has an extra assumption".to_string()) });
+        }
+        if (__v_9 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output has an extra assumption".to_string()) });
+        }
+        if (__v_10 != __v_12) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output has an extra assumption".to_string()) });
+        }
+        let __ret: [G; OUT_228] = [];
+        if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_2]; 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 { let __r = record.function_queries[227].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+        match __v_8.as_canonical_u64() {
+          1u64 => {
+            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_7, __v_2, __v_3]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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] = [];
+            if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+            match __v_9.as_canonical_u64() {
+              0u64 => {
+                let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __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 { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.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 __v_13: G = G::from_u64(1);
+                if (__v_12 != __v_13) {
+                  return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: outstanding assumption mismatch".to_string()) });
+                }
+                let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_6, __v_7, __v_2, __v_11]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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] = [];
+                if !unconstrained { record.virt += record.function_queries[228].weight(); } record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                return Ok(__ret);
+              },
+              _ => {
+                return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64()));
+              },
+            }
+          },
+        }
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_229: usize = 1;
+const IN_229: usize = 1;
+const OUT_229: usize = 3;
+fn aiur_fn_229(
+  inp: [G; IN_229],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_229], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_229] = [__v_3, __v_4, __v_2];
+        if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      1u64 => {
+        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+        let __v_4: G = __r_arr[1];
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_229] = [__v_5, __v_3, __v_4];
+        if !unconstrained { record.virt += record.function_queries[229].weight(); } record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_182: usize = 7;
-const IN_182: usize = 7;
-const OUT_182: usize = 2;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_230: usize = 1;
+const IN_230: usize = 1;
+const OUT_230: usize = 3;
+fn aiur_fn_230(
+  inp: [G; IN_230],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_230], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = record.function_queries[77].replay_at(__i); record.virt += __r; } 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_206] = { let __args: [G; IN_206] = [__v_2]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_4]; 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 { let __r = record.function_queries[229].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+    let __v_6: G = __r_arr[1];
+    let __v_7: G = __r_arr[2];
+    let __v_8: G = G::from_u64(229);
+    if (__v_1 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: child claim is not CheckEnv".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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()) });
+    }
+    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()) });
+    }
+    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()) });
+    }
+    let __ret: [G; OUT_230] = [__v_3, __v_5, __v_6];
+    if !unconstrained { record.virt += record.function_queries[230].weight(); } record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_231: usize = 8;
+const IN_231: usize = 8;
+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_231], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = G::from_u64(4);
+    let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_9: G = __io_pair.0;
+    let __v_10: G = __io_pair.1;
+    let __v_11: G = G::from_u64(4);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; 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_12: G = __r_arr[0];
+    let __v_13: G = G::from_u64(103);
+    let __v_14: G = G::from_u64(230);
+    let __v_15: G = G::from_u64(9);
+    let __v_16: G = G::from_u64(106);
+    let __v_17: G = G::from_u64(133);
+    let __v_18: G = G::from_u64(174);
+    let __v_19: G = G::from_u64(103);
+    let __v_20: G = G::from_u64(187);
+    let __v_21: G = G::from_u64(114);
+    let __v_22: G = G::from_u64(243);
+    let __v_23: G = G::from_u64(110);
+    let __v_24: G = G::from_u64(60);
+    let __v_25: G = G::from_u64(58);
+    let __v_26: G = G::from_u64(245);
+    let __v_27: G = G::from_u64(79);
+    let __v_28: G = G::from_u64(165);
+    let __v_29: G = G::from_u64(127);
+    let __v_30: G = G::from_u64(82);
+    let __v_31: G = G::from_u64(14);
+    let __v_32: G = G::from_u64(81);
+    let __v_33: G = G::from_u64(140);
+    let __v_34: G = G::from_u64(104);
+    let __v_35: G = G::from_u64(5);
+    let __v_36: G = G::from_u64(155);
+    let __v_37: G = G::from_u64(171);
+    let __v_38: G = G::from_u64(217);
+    let __v_39: G = G::from_u64(131);
+    let __v_40: G = G::from_u64(31);
+    let __v_41: G = G::from_u64(25);
+    let __v_42: G = G::from_u64(205);
+    let __v_43: G = G::from_u64(224);
+    let __v_44: G = G::from_u64(91);
+    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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_48: G = G::from_u64(0);
+    let __v_49: G = G::from_u64(0);
+    let __v_50: G = G::from_u64(0);
+    let __v_51: G = G::from_u64(0);
+    let __v_52: G = G::from_u64(0);
+    let __v_53: G = G::from_u64(0);
+    let __v_54: G = G::from_u64(0);
+    let __v_55: G = G::from_u64(0);
+    let __v_56: G = G::from_u64(0);
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_59: 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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_60: G = G::from_u64(1);
+    let __v_61: G = G::from_u64(1);
+    let __v_62: G = { let __values: [G; 34] = [__v_60, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_63: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+    let __v_65: G = __r_arr[1];
+    let __v_66: G = __r_arr[2];
+    let __v_67: G = __r_arr[3];
+    let __v_68: G = __r_arr[4];
+    let __v_69: G = __r_arr[5];
+    let __v_70: G = __r_arr[6];
+    let __v_71: G = __r_arr[7];
+    let __v_72: G = __r_arr[8];
+    let __v_73: G = __r_arr[9];
+    let __v_74: G = __r_arr[10];
+    let __v_75: G = __r_arr[11];
+    let __v_76: G = __r_arr[12];
+    let __v_77: G = __r_arr[13];
+    let __v_78: G = __r_arr[14];
+    let __v_79: G = __r_arr[15];
+    let __v_80: G = __r_arr[16];
+    let __v_81: G = __r_arr[17];
+    let __v_82: G = __r_arr[18];
+    let __v_83: G = __r_arr[19];
+    let __v_84: G = __r_arr[20];
+    let __v_85: G = __r_arr[21];
+    let __v_86: G = __r_arr[22];
+    let __v_87: G = __r_arr[23];
+    let __v_88: G = __r_arr[24];
+    let __v_89: G = __r_arr[25];
+    let __v_90: G = __r_arr[26];
+    let __v_91: G = __r_arr[27];
+    let __v_92: G = __r_arr[28];
+    let __v_93: G = __r_arr[29];
+    let __v_94: G = __r_arr[30];
+    let __v_95: G = __r_arr[31];
+    let __v_96: G = G::from_u64(256);
+    let __v_97: G = (__v_96 * __v_65);
+    let __v_98: G = G::from_u64(65536);
+    let __v_99: G = (__v_98 * __v_66);
+    let __v_100: G = G::from_u64(16777216);
+    let __v_101: G = (__v_100 * __v_67);
+    let __v_102: G = (__v_99 + __v_101);
+    let __v_103: G = (__v_97 + __v_102);
+    let __v_104: G = (__v_64 + __v_103);
+    let __v_105: G = G::from_u64(256);
+    let __v_106: G = (__v_105 * __v_69);
+    let __v_107: G = G::from_u64(65536);
+    let __v_108: G = (__v_107 * __v_70);
+    let __v_109: G = G::from_u64(16777216);
+    let __v_110: G = (__v_109 * __v_71);
+    let __v_111: G = (__v_108 + __v_110);
+    let __v_112: G = (__v_106 + __v_111);
+    let __v_113: G = (__v_68 + __v_112);
+    let __v_114: G = G::from_u64(256);
+    let __v_115: G = (__v_114 * __v_73);
+    let __v_116: G = G::from_u64(65536);
+    let __v_117: G = (__v_116 * __v_74);
+    let __v_118: G = G::from_u64(16777216);
+    let __v_119: G = (__v_118 * __v_75);
+    let __v_120: G = (__v_117 + __v_119);
+    let __v_121: G = (__v_115 + __v_120);
+    let __v_122: G = (__v_72 + __v_121);
+    let __v_123: G = G::from_u64(256);
+    let __v_124: G = (__v_123 * __v_77);
+    let __v_125: G = G::from_u64(65536);
+    let __v_126: G = (__v_125 * __v_78);
+    let __v_127: G = G::from_u64(16777216);
+    let __v_128: G = (__v_127 * __v_79);
+    let __v_129: G = (__v_126 + __v_128);
+    let __v_130: G = (__v_124 + __v_129);
+    let __v_131: G = (__v_76 + __v_130);
+    let __v_132: G = G::from_u64(256);
+    let __v_133: G = (__v_132 * __v_81);
+    let __v_134: G = G::from_u64(65536);
+    let __v_135: G = (__v_134 * __v_82);
+    let __v_136: G = G::from_u64(16777216);
+    let __v_137: G = (__v_136 * __v_83);
+    let __v_138: G = (__v_135 + __v_137);
+    let __v_139: G = (__v_133 + __v_138);
+    let __v_140: G = (__v_80 + __v_139);
+    let __v_141: G = G::from_u64(256);
+    let __v_142: G = (__v_141 * __v_85);
+    let __v_143: G = G::from_u64(65536);
+    let __v_144: G = (__v_143 * __v_86);
+    let __v_145: G = G::from_u64(16777216);
+    let __v_146: G = (__v_145 * __v_87);
+    let __v_147: G = (__v_144 + __v_146);
+    let __v_148: G = (__v_142 + __v_147);
+    let __v_149: G = (__v_84 + __v_148);
+    let __v_150: G = G::from_u64(256);
+    let __v_151: G = (__v_150 * __v_89);
+    let __v_152: G = G::from_u64(65536);
+    let __v_153: G = (__v_152 * __v_90);
+    let __v_154: G = G::from_u64(16777216);
+    let __v_155: G = (__v_154 * __v_91);
+    let __v_156: G = (__v_153 + __v_155);
+    let __v_157: G = (__v_151 + __v_156);
+    let __v_158: G = (__v_88 + __v_157);
+    let __v_159: G = G::from_u64(256);
+    let __v_160: G = (__v_159 * __v_93);
+    let __v_161: G = G::from_u64(65536);
+    let __v_162: G = (__v_161 * __v_94);
+    let __v_163: G = G::from_u64(16777216);
+    let __v_164: G = (__v_163 * __v_95);
+    let __v_165: G = (__v_162 + __v_164);
+    let __v_166: G = (__v_160 + __v_165);
+    let __v_167: G = (__v_92 + __v_166);
+    if (__v_104 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_104.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_113 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_113.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_122 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_122.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_131 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_140 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_140.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_149 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_158 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_158.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    if (__v_167 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("join: claim preimage digest mismatch".to_string()) });
+    }
+    let __ret: [G; OUT_231] = [__v_12];
+    if !unconstrained { record.virt += record.function_queries[231].weight(); } record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_232: usize = 2;
+const IN_232: usize = 2;
+const OUT_232: usize = 1;
+fn aiur_fn_232(
+  inp: [G; IN_232],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_232], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_1]; 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 { let __r = record.function_queries[256].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = __r_arr[1];
+    let __v_4: G = __r_arr[2];
+    let __v_5: G = __r_arr[3];
+    let __v_6: G = __r_arr[4];
+    let __v_7: G = __r_arr[5];
+    let __v_8: G = __r_arr[6];
+    let __v_9: G = __r_arr[7];
+    let __v_10: G = G::from_u64(256);
+    let __v_11: G = (__v_10 * __v_3);
+    let __v_12: G = G::from_u64(65536);
+    let __v_13: G = (__v_12 * __v_4);
+    let __v_14: G = G::from_u64(16777216);
+    let __v_15: G = (__v_14 * __v_5);
+    let __v_16: G = G::from_u64(4294967296);
+    let __v_17: G = (__v_16 * __v_6);
+    let __v_18: G = G::from_u64(1099511627776);
+    let __v_19: G = (__v_18 * __v_7);
+    let __v_20: G = G::from_u64(281474976710656);
+    let __v_21: G = (__v_20 * __v_8);
+    let __v_22: G = G::from_u64(72057594037927936);
+    let __v_23: G = (__v_22 * __v_9);
+    let __v_24: G = (__v_21 + __v_23);
+    let __v_25: G = (__v_19 + __v_24);
+    let __v_26: G = (__v_17 + __v_25);
+    let __v_27: G = (__v_15 + __v_26);
+    let __v_28: G = (__v_13 + __v_27);
+    let __v_29: G = (__v_11 + __v_28);
+    let __v_30: G = (__v_2 + __v_29);
+    let __ret: [G; OUT_232] = [__v_30];
+    if !unconstrained { record.virt += record.function_queries[232].weight(); } record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_233: usize = 2;
+const IN_233: usize = 2;
+const OUT_233: usize = 8;
+fn aiur_fn_233(
+  inp: [G; IN_233],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_233], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_1]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __v_3: G = G::from_u64(1);
+    let __v_4: G = (__v_1 + __v_3);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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 = G::from_u64(2);
+    let __v_7: G = (__v_1 + __v_6);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_7]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_8: G = __r_arr[0];
+    let __v_9: G = G::from_u64(3);
+    let __v_10: G = (__v_1 + __v_9);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_10]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __v_12: G = G::from_u64(4);
+    let __v_13: G = (__v_1 + __v_12);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_13]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __v_15: G = G::from_u64(5);
+    let __v_16: G = (__v_1 + __v_15);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_16]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_17: G = __r_arr[0];
+    let __v_18: G = G::from_u64(6);
+    let __v_19: G = (__v_1 + __v_18);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_19]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_20: G = __r_arr[0];
+    let __v_21: G = G::from_u64(7);
+    let __v_22: G = (__v_1 + __v_21);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0, __v_22]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+    let __ret: [G; OUT_233] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23];
+    if !unconstrained { record.virt += record.function_queries[233].weight(); } record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_234: usize = 16;
+const IN_234: usize = 16;
+const OUT_234: usize = 0;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_182], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -17217,71 +22524,100 @@ fn aiur_fn_182(
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_7: G = __loaded[0];
-    let __v_8: G = __loaded[1];
-    let __v_9: G = __loaded[2];
-    match __v_7.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_182] = [__v_0, __v_1];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    if (__v_0 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    if (__v_1 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
+    }
+    if (__v_2 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
+    }
+    if (__v_3 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+    }
+    if (__v_4 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    }
+    if (__v_5 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
+    }
+    if (__v_6 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    }
+    if (__v_7 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_234] = [];
+    if !unconstrained { record.virt += record.function_queries[234].weight(); } record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_235: usize = 1;
+const IN_235: usize = 1;
+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_235], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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 __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } };
-        let __v_10: G = __r_arr[0];
-        let __v_11: G = __r_arr[1];
-        let __v_12: G = (__v_3 + __v_10);
-        let __v_13: G = (__v_4 + __v_11);
-        let __v_14: G = (__v_12 * __v_12);
-        let __v_15: G = G::from_u64(7);
-        let __v_16: G = (__v_13 * __v_13);
-        let __v_17: G = (__v_15 * __v_16);
-        let __v_18: G = (__v_14 - __v_17);
-        let __v_19: G = g_inverse_value(__v_18);
-        let __v_20: G = (__v_18 * __v_19);
-        let __v_21: G = G::from_u64(1);
-        let __v_22: G = (__v_20 - __v_21);
-        let __v_23: G = (__v_18 * __v_22);
-        let __v_24: G = G::from_u64(0);
-        if (__v_23 != __v_24) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None });
+        let __loaded: [G; 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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+        let __v_5: G = __loaded[1];
+        let __v_6: G = __loaded[2];
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = G::from_u64(1);
+        if (__v_4 != __v_7) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("join: child proof must expose exactly one claim".to_string()) });
         }
-        let __v_25: G = (__v_19 * __v_22);
-        let __v_26: G = G::from_u64(0);
-        if (__v_25 != __v_26) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None });
+        if (__v_5 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: child proof must expose exactly one claim".to_string()) });
         }
-        let __v_27: G = (__v_12 * __v_19);
-        let __v_28: G = G::from_u64(0);
-        let __v_29: G = (__v_28 - __v_13);
-        let __v_30: G = (__v_29 * __v_19);
-        let __v_31: G = (__v_0 + __v_27);
-        let __v_32: G = (__v_1 + __v_30);
-        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-        let __v_33: G = __r_arr[0];
-        let __v_34: G = __r_arr[1];
-        let __ret: [G; OUT_182] = [__v_33, __v_34];
-        if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        if (__v_6 != __v_8) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: child proof must expose exactly one claim".to_string()) });
+        }
+        let __ret: [G; OUT_235] = [__v_2];
+        if !unconstrained { record.virt += record.function_queries[235].weight(); } record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_183: usize = 37;
-const IN_183: usize = 37;
-const OUT_183: usize = 1;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_236: usize = 13;
+const IN_236: usize = 13;
+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_183], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -17295,48 +22631,116 @@ fn aiur_fn_183(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __v_13: G = inp[13];
-    let __v_14: G = inp[14];
-    let __v_15: G = inp[15];
-    let __v_16: G = inp[16];
-    let __v_17: G = inp[17];
-    let __v_18: G = inp[18];
-    let __v_19: G = inp[19];
-    let __v_20: G = inp[20];
-    let __v_21: G = inp[21];
-    let __v_22: G = inp[22];
-    let __v_23: G = inp[23];
-    let __v_24: G = inp[24];
-    let __v_25: G = inp[25];
-    let __v_26: G = inp[26];
-    let __v_27: G = inp[27];
-    let __v_28: G = inp[28];
-    let __v_29: G = inp[29];
-    let __v_30: G = inp[30];
-    let __v_31: G = inp[31];
-    let __v_32: G = inp[32];
-    let __v_33: G = inp[33];
-    let __v_34: G = inp[34];
-    let __v_35: G = inp[35];
-    let __v_36: G = inp[36];
-    match __v_0.as_canonical_u64() {
+    let __v_13: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_14: G = __io_pair.0;
+    let __v_15: G = __io_pair.1;
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_18: G = __r_arr[0];
+    let __v_19: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_20: G = __r_arr[0];
+    let __v_21: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_22: G = __r_arr[0];
+    let __v_23: G = __r_arr[1];
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
+    let __v_24: G = __r_arr[0];
+    let __v_25: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_26: G = __r_arr[0];
+    let __v_27: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_28: G = __r_arr[0];
+    let __v_29: G = __r_arr[1];
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
+    let __v_31: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; 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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
+    let __v_36: G = __r_arr[0];
+    let __v_37: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_38: G = __r_arr[0];
+    let __v_39: G = __r_arr[1];
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+    let __v_41: G = __r_arr[1];
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
+    let __v_42: G = __r_arr[0];
+    let __v_43: G = __r_arr[1];
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
+    let __v_45: G = __r_arr[1];
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_46: G = __r_arr[0];
+    let __v_47: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_48: G = __r_arr[0];
+    let __v_49: G = __r_arr[1];
+    let __v_50: G = __r_arr[2];
+    let __v_51: G = __r_arr[3];
+    let __v_52: G = __r_arr[4];
+    let __v_53: G = __r_arr[5];
+    let __v_54: G = __r_arr[6];
+    let __v_55: G = __r_arr[7];
+    let __v_56: G = __r_arr[8];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_57: G = __r_arr[0];
+    let __v_58: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; 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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __v_61: G = __r_arr[2];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_62: G = __r_arr[0];
+    let __v_63: G = __r_arr[1];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_64: G = __r_arr[0];
+    let __v_65: G = __r_arr[1];
+    let __v_66: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_67: G = __io_pair.0;
+    let __v_68: G = __io_pair.1;
+    let __v_69: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; 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_70: G = __r_arr[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_71: G = __r_arr[0];
+    let __v_72: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_72, __v_71]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    match __v_18.as_canonical_u64() {
       _ => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_75: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           _ => {
-            match __v_12.as_canonical_u64() {
+            match __v_0.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-                let __v_37: G = __r_arr[0];
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-                let __v_38: G = __r_arr[0];
-                match __v_13.as_canonical_u64() {
+                match __v_18.as_canonical_u64() {
                   _ => {
-                    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
+                    let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8, __v_18]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_76: G = __r_arr[0];
+                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11, __v_18]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_77: G = __r_arr[0];
+                    match __v_20.as_canonical_u64() {
+                      _ => {
+                        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_9.as_canonical_u64() {
   0u64 => {
-    let __v_39: G = G::from_u64(1);
-    let __v_40: G = G::from_u64(1);
-    let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_0 [__v_41];
+    let __v_78: G = G::from_u64(1);
+    let __v_79: G = G::from_u64(1);
+    let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_0 [__v_80];
   },
   1u64 => {
     break '__mc_0 [__v_10];
@@ -17346,523 +22750,614 @@ fn aiur_fn_183(
   },
 }
  };
-                    let __v_39: G = __mc_out___mc_0[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_17, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                    let __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                    let __v_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_39, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                    let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_12, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                    let __v_43: G = __r_arr[0];
-                    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_7, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-                    let __v_44: G = __r_arr[0];
-                    let __v_45: G = G::from_u64(0);
-                    let __v_46: G = G::from_u64(109);
-                    let __v_47: G = G::from_u64(0);
-                    let __v_48: G = G::from_u64(117);
-                    let __v_49: G = G::from_u64(0);
-                    let __v_50: G = G::from_u64(108);
-                    let __v_51: G = G::from_u64(0);
-                    let __v_52: G = G::from_u64(116);
-                    let __v_53: G = G::from_u64(0);
-                    let __v_54: G = G::from_u64(105);
-                    let __v_55: G = G::from_u64(0);
-                    let __v_56: G = G::from_u64(45);
-                    let __v_57: G = G::from_u64(0);
-                    let __v_58: G = G::from_u64(115);
-                    let __v_59: G = G::from_u64(0);
-                    let __v_60: G = G::from_u64(116);
-                    let __v_61: G = G::from_u64(0);
-                    let __v_62: G = G::from_u64(97);
-                    let __v_63: G = G::from_u64(0);
-                    let __v_64: G = G::from_u64(114);
-                    let __v_65: G = G::from_u64(0);
-                    let __v_66: G = G::from_u64(107);
-                    let __v_67: G = G::from_u64(0);
-                    let __v_68: G = G::from_u64(47);
-                    let __v_69: G = G::from_u64(0);
-                    let __v_70: G = G::from_u64(118);
-                    let __v_71: G = G::from_u64(0);
-                    let __v_72: G = G::from_u64(48);
-                    let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_74: G = { let __values: [G; 3] = [__v_69, __v_70, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_75: G = { let __values: [G; 3] = [__v_67, __v_68, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_76: G = { let __values: [G; 3] = [__v_65, __v_66, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_77: G = { let __values: [G; 3] = [__v_63, __v_64, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_78: G = { let __values: [G; 3] = [__v_61, __v_62, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_79: G = { let __values: [G; 3] = [__v_59, __v_60, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_80: G = { let __values: [G; 3] = [__v_57, __v_58, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_81: G = { let __values: [G; 3] = [__v_55, __v_56, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_82: G = { let __values: [G; 3] = [__v_53, __v_54, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_83: G = { let __values: [G; 3] = [__v_51, __v_52, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_84: G = { let __values: [G; 3] = [__v_49, __v_50, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_85: G = { let __values: [G; 3] = [__v_47, __v_48, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_86: G = { let __values: [G; 3] = [__v_45, __v_46, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __v_87: G = G::from_u64(1);
-                    let __v_88: G = G::from_u64(1);
-                    let __v_89: G = { let __values: [G; 3] = [__v_87, __v_88, __v_88]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_86, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_90: G = __r_arr[0];
-                    let __v_91: G = __r_arr[1];
-                    let __v_92: G = __r_arr[2];
-                    let __v_93: G = __r_arr[3];
-                    let __v_94: G = __r_arr[4];
-                    let __v_95: G = __r_arr[5];
-                    let __v_96: G = __r_arr[6];
-                    let __v_97: G = __r_arr[7];
-                    let __v_98: G = __r_arr[8];
-                    let __v_99: G = __r_arr[9];
-                    let __v_100: G = __r_arr[10];
-                    let __v_101: G = __r_arr[11];
-                    let __v_102: G = __r_arr[12];
-                    let __v_103: G = __r_arr[13];
-                    let __v_104: G = __r_arr[14];
-                    let __v_105: G = __r_arr[15];
-                    let __v_106: G = __r_arr[16];
-                    let __v_107: G = __r_arr[17];
-                    let __v_108: G = G::from_u64(1);
-                    let __v_109: G = G::from_u64(1);
-                    let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_111: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_112: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_106, __v_112]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_113: G = __r_arr[0];
-                    let __v_114: G = G::from_u64(1);
-                    let __v_115: G = G::from_u64(1);
-                    let __v_116: G = { let __values: [G; 3] = [__v_114, __v_115, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_113, __v_116]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_117: G = __r_arr[0];
-                    let __v_118: G = __r_arr[1];
-                    let __v_119: G = __r_arr[2];
-                    let __v_120: G = __r_arr[3];
-                    let __v_121: G = __r_arr[4];
-                    let __v_122: G = __r_arr[5];
-                    let __v_123: G = __r_arr[6];
-                    let __v_124: G = __r_arr[7];
-                    let __v_125: G = __r_arr[8];
-                    let __v_126: G = __r_arr[9];
-                    let __v_127: G = __r_arr[10];
-                    let __v_128: G = __r_arr[11];
-                    let __v_129: G = __r_arr[12];
-                    let __v_130: G = __r_arr[13];
-                    let __v_131: G = __r_arr[14];
-                    let __v_132: G = __r_arr[15];
-                    let __v_133: G = __r_arr[16];
-                    let __v_134: G = __r_arr[17];
-                    let __v_135: G = G::from_u64(1);
-                    let __v_136: G = G::from_u64(1);
-                    let __v_137: G = { let __values: [G; 3] = [__v_135, __v_136, __v_136]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_138: G = __r_arr[0];
-                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_138]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                    let __v_139: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_133, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_140: G = __r_arr[0];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_140, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                    let __v_141: G = __r_arr[0];
-                    let __v_142: G = G::from_u64(1);
-                    let __v_143: G = G::from_u64(1);
-                    let __v_144: G = { let __values: [G; 3] = [__v_142, __v_143, __v_143]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_16, __v_144]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                    let __v_145: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_141, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_146: G = __r_arr[0];
-                    let __v_147: G = G::from_u64(1);
-                    let __v_148: G = G::from_u64(1);
-                    let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_146, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_150: G = __r_arr[0];
-                    let __v_151: G = __r_arr[1];
-                    let __v_152: G = __r_arr[2];
-                    let __v_153: G = __r_arr[3];
-                    let __v_154: G = __r_arr[4];
-                    let __v_155: G = __r_arr[5];
-                    let __v_156: G = __r_arr[6];
-                    let __v_157: G = __r_arr[7];
-                    let __v_158: G = __r_arr[8];
-                    let __v_159: G = __r_arr[9];
-                    let __v_160: G = __r_arr[10];
-                    let __v_161: G = __r_arr[11];
-                    let __v_162: G = __r_arr[12];
-                    let __v_163: G = __r_arr[13];
-                    let __v_164: G = __r_arr[14];
-                    let __v_165: G = __r_arr[15];
-                    let __v_166: G = __r_arr[16];
-                    let __v_167: G = __r_arr[17];
-                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_166, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                    let __v_168: G = __r_arr[0];
-                    let __v_169: G = G::from_u64(1);
-                    let __v_170: G = G::from_u64(1);
-                    let __v_171: G = { let __values: [G; 3] = [__v_169, __v_170, __v_170]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_168, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_172: G = __r_arr[0];
-                    let __v_173: G = __r_arr[1];
-                    let __v_174: G = __r_arr[2];
-                    let __v_175: G = __r_arr[3];
-                    let __v_176: G = __r_arr[4];
-                    let __v_177: G = __r_arr[5];
-                    let __v_178: G = __r_arr[6];
-                    let __v_179: G = __r_arr[7];
-                    let __v_180: G = __r_arr[8];
-                    let __v_181: G = __r_arr[9];
-                    let __v_182: G = __r_arr[10];
-                    let __v_183: G = __r_arr[11];
-                    let __v_184: G = __r_arr[12];
-                    let __v_185: G = __r_arr[13];
-                    let __v_186: G = __r_arr[14];
-                    let __v_187: G = __r_arr[15];
-                    let __v_188: G = __r_arr[16];
-                    let __v_189: G = __r_arr[17];
-                    let __v_190: G = G::from_u64(256);
-                    let __v_191: G = (__v_190 * __v_91);
-                    let __v_192: G = G::from_u64(65536);
-                    let __v_193: G = (__v_192 * __v_92);
-                    let __v_194: G = G::from_u64(16777216);
-                    let __v_195: G = (__v_194 * __v_93);
-                    let __v_196: G = G::from_u64(4294967296);
-                    let __v_197: G = (__v_196 * __v_94);
-                    let __v_198: G = G::from_u64(1099511627776);
-                    let __v_199: G = (__v_198 * __v_95);
-                    let __v_200: G = G::from_u64(281474976710656);
-                    let __v_201: G = (__v_200 * __v_96);
-                    let __v_202: G = G::from_u64(72057594037927936);
-                    let __v_203: G = (__v_202 * __v_97);
-                    let __v_204: G = (__v_201 + __v_203);
-                    let __v_205: G = (__v_199 + __v_204);
-                    let __v_206: G = (__v_197 + __v_205);
-                    let __v_207: G = (__v_195 + __v_206);
-                    let __v_208: G = (__v_193 + __v_207);
-                    let __v_209: G = (__v_191 + __v_208);
-                    let __v_210: G = (__v_90 + __v_209);
-                    let __v_211: G = G::from_u64(256);
-                    let __v_212: G = (__v_211 * __v_99);
-                    let __v_213: G = G::from_u64(65536);
-                    let __v_214: G = (__v_213 * __v_100);
-                    let __v_215: G = G::from_u64(16777216);
-                    let __v_216: G = (__v_215 * __v_101);
-                    let __v_217: G = G::from_u64(4294967296);
-                    let __v_218: G = (__v_217 * __v_102);
-                    let __v_219: G = G::from_u64(1099511627776);
-                    let __v_220: G = (__v_219 * __v_103);
-                    let __v_221: G = G::from_u64(281474976710656);
-                    let __v_222: G = (__v_221 * __v_104);
-                    let __v_223: G = G::from_u64(72057594037927936);
-                    let __v_224: G = (__v_223 * __v_105);
-                    let __v_225: G = (__v_222 + __v_224);
-                    let __v_226: G = (__v_220 + __v_225);
-                    let __v_227: G = (__v_218 + __v_226);
-                    let __v_228: G = (__v_216 + __v_227);
-                    let __v_229: G = (__v_214 + __v_228);
-                    let __v_230: G = (__v_212 + __v_229);
-                    let __v_231: G = (__v_98 + __v_230);
-                    let __v_232: G = G::from_u64(256);
-                    let __v_233: G = (__v_232 * __v_118);
-                    let __v_234: G = G::from_u64(65536);
-                    let __v_235: G = (__v_234 * __v_119);
-                    let __v_236: G = G::from_u64(16777216);
-                    let __v_237: G = (__v_236 * __v_120);
-                    let __v_238: G = G::from_u64(4294967296);
-                    let __v_239: G = (__v_238 * __v_121);
-                    let __v_240: G = G::from_u64(1099511627776);
-                    let __v_241: G = (__v_240 * __v_122);
-                    let __v_242: G = G::from_u64(281474976710656);
-                    let __v_243: G = (__v_242 * __v_123);
-                    let __v_244: G = G::from_u64(72057594037927936);
-                    let __v_245: G = (__v_244 * __v_124);
-                    let __v_246: G = (__v_243 + __v_245);
-                    let __v_247: G = (__v_241 + __v_246);
-                    let __v_248: G = (__v_239 + __v_247);
-                    let __v_249: G = (__v_237 + __v_248);
-                    let __v_250: G = (__v_235 + __v_249);
-                    let __v_251: G = (__v_233 + __v_250);
-                    let __v_252: G = (__v_117 + __v_251);
-                    let __v_253: G = G::from_u64(256);
-                    let __v_254: G = (__v_253 * __v_126);
-                    let __v_255: G = G::from_u64(65536);
-                    let __v_256: G = (__v_255 * __v_127);
-                    let __v_257: G = G::from_u64(16777216);
-                    let __v_258: G = (__v_257 * __v_128);
-                    let __v_259: G = G::from_u64(4294967296);
-                    let __v_260: G = (__v_259 * __v_129);
-                    let __v_261: G = G::from_u64(1099511627776);
-                    let __v_262: G = (__v_261 * __v_130);
-                    let __v_263: G = G::from_u64(281474976710656);
-                    let __v_264: G = (__v_263 * __v_131);
-                    let __v_265: G = G::from_u64(72057594037927936);
-                    let __v_266: G = (__v_265 * __v_132);
-                    let __v_267: G = (__v_264 + __v_266);
-                    let __v_268: G = (__v_262 + __v_267);
-                    let __v_269: G = (__v_260 + __v_268);
-                    let __v_270: G = (__v_258 + __v_269);
-                    let __v_271: G = (__v_256 + __v_270);
-                    let __v_272: G = (__v_254 + __v_271);
-                    let __v_273: G = (__v_125 + __v_272);
-                    let __v_274: G = G::from_u64(256);
-                    let __v_275: G = (__v_274 * __v_151);
-                    let __v_276: G = G::from_u64(65536);
-                    let __v_277: G = (__v_276 * __v_152);
-                    let __v_278: G = G::from_u64(16777216);
-                    let __v_279: G = (__v_278 * __v_153);
-                    let __v_280: G = G::from_u64(4294967296);
-                    let __v_281: G = (__v_280 * __v_154);
-                    let __v_282: G = G::from_u64(1099511627776);
-                    let __v_283: G = (__v_282 * __v_155);
-                    let __v_284: G = G::from_u64(281474976710656);
-                    let __v_285: G = (__v_284 * __v_156);
-                    let __v_286: G = G::from_u64(72057594037927936);
-                    let __v_287: G = (__v_286 * __v_157);
-                    let __v_288: G = (__v_285 + __v_287);
-                    let __v_289: G = (__v_283 + __v_288);
-                    let __v_290: G = (__v_281 + __v_289);
-                    let __v_291: G = (__v_279 + __v_290);
-                    let __v_292: G = (__v_277 + __v_291);
-                    let __v_293: G = (__v_275 + __v_292);
-                    let __v_294: G = (__v_150 + __v_293);
-                    let __v_295: G = G::from_u64(256);
-                    let __v_296: G = (__v_295 * __v_159);
-                    let __v_297: G = G::from_u64(65536);
-                    let __v_298: G = (__v_297 * __v_160);
-                    let __v_299: G = G::from_u64(16777216);
-                    let __v_300: G = (__v_299 * __v_161);
-                    let __v_301: G = G::from_u64(4294967296);
-                    let __v_302: G = (__v_301 * __v_162);
-                    let __v_303: G = G::from_u64(1099511627776);
-                    let __v_304: G = (__v_303 * __v_163);
-                    let __v_305: G = G::from_u64(281474976710656);
-                    let __v_306: G = (__v_305 * __v_164);
-                    let __v_307: G = G::from_u64(72057594037927936);
-                    let __v_308: G = (__v_307 * __v_165);
-                    let __v_309: G = (__v_306 + __v_308);
-                    let __v_310: G = (__v_304 + __v_309);
-                    let __v_311: G = (__v_302 + __v_310);
-                    let __v_312: G = (__v_300 + __v_311);
-                    let __v_313: G = (__v_298 + __v_312);
-                    let __v_314: G = (__v_296 + __v_313);
-                    let __v_315: G = (__v_158 + __v_314);
-                    let __v_316: G = G::from_u64(256);
-                    let __v_317: G = (__v_316 * __v_173);
-                    let __v_318: G = G::from_u64(65536);
-                    let __v_319: G = (__v_318 * __v_174);
-                    let __v_320: G = G::from_u64(16777216);
-                    let __v_321: G = (__v_320 * __v_175);
-                    let __v_322: G = G::from_u64(4294967296);
-                    let __v_323: G = (__v_322 * __v_176);
-                    let __v_324: G = G::from_u64(1099511627776);
-                    let __v_325: G = (__v_324 * __v_177);
-                    let __v_326: G = G::from_u64(281474976710656);
-                    let __v_327: G = (__v_326 * __v_178);
-                    let __v_328: G = G::from_u64(72057594037927936);
-                    let __v_329: G = (__v_328 * __v_179);
-                    let __v_330: G = (__v_327 + __v_329);
-                    let __v_331: G = (__v_325 + __v_330);
-                    let __v_332: G = (__v_323 + __v_331);
-                    let __v_333: G = (__v_321 + __v_332);
-                    let __v_334: G = (__v_319 + __v_333);
-                    let __v_335: G = (__v_317 + __v_334);
-                    let __v_336: G = (__v_172 + __v_335);
-                    let __v_337: G = G::from_u64(256);
-                    let __v_338: G = (__v_337 * __v_181);
-                    let __v_339: G = G::from_u64(65536);
-                    let __v_340: G = (__v_339 * __v_182);
-                    let __v_341: G = G::from_u64(16777216);
-                    let __v_342: G = (__v_341 * __v_183);
-                    let __v_343: G = G::from_u64(4294967296);
-                    let __v_344: G = (__v_343 * __v_184);
-                    let __v_345: G = G::from_u64(1099511627776);
-                    let __v_346: G = (__v_345 * __v_185);
-                    let __v_347: G = G::from_u64(281474976710656);
-                    let __v_348: G = (__v_347 * __v_186);
-                    let __v_349: G = G::from_u64(72057594037927936);
-                    let __v_350: G = (__v_349 * __v_187);
-                    let __v_351: G = (__v_348 + __v_350);
-                    let __v_352: G = (__v_346 + __v_351);
-                    let __v_353: G = (__v_344 + __v_352);
-                    let __v_354: G = (__v_342 + __v_353);
-                    let __v_355: G = (__v_340 + __v_354);
-                    let __v_356: G = (__v_338 + __v_355);
-                    let __v_357: G = (__v_180 + __v_356);
-                    let __v_358: G = G::from_u64(0);
-                    let __v_359: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_358, __v_359, __v_35, __v_210, __v_231, __v_252, __v_273]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                    let __v_360: G = __r_arr[0];
-                    let __v_361: G = __r_arr[1];
-                    let __v_362: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_37, __v_38, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_362, __v_360, __v_361, __v_210, __v_231, __v_252, __v_273, __v_294, __v_315, __v_336, __v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                    let __v_363: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_364: G = __r_arr[0];
-                    match __v_18.as_canonical_u64() {
-                      _ => {
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                        let __v_365: G = __r_arr[0];
-                        let __v_366: G = G::from_u64(1);
-                        let __v_367: G = G::from_u64(1);
-                        let __v_368: G = { let __values: [G; 3] = [__v_366, __v_367, __v_367]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_31.as_canonical_u64() {
+                        let __v_78: G = __mc_out___mc_0[0];
+                        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_30, __v_70]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_79: G = __r_arr[0];
+                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_20, __v_79]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_80: G = __r_arr[0];
+                        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_78, __v_80]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_81: G = __r_arr[0];
+                        let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_18, __v_81]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_82: G = __r_arr[0];
+                        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_7, __v_82]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_83: G = __r_arr[0];
+                        let __v_84: G = G::from_u64(0);
+                        let __v_85: G = G::from_u64(109);
+                        let __v_86: G = G::from_u64(0);
+                        let __v_87: G = G::from_u64(117);
+                        let __v_88: G = G::from_u64(0);
+                        let __v_89: G = G::from_u64(108);
+                        let __v_90: G = G::from_u64(0);
+                        let __v_91: G = G::from_u64(116);
+                        let __v_92: G = G::from_u64(0);
+                        let __v_93: G = G::from_u64(105);
+                        let __v_94: G = G::from_u64(0);
+                        let __v_95: G = G::from_u64(45);
+                        let __v_96: G = G::from_u64(0);
+                        let __v_97: G = G::from_u64(115);
+                        let __v_98: G = G::from_u64(0);
+                        let __v_99: G = G::from_u64(116);
+                        let __v_100: G = G::from_u64(0);
+                        let __v_101: G = G::from_u64(97);
+                        let __v_102: G = G::from_u64(0);
+                        let __v_103: G = G::from_u64(114);
+                        let __v_104: G = G::from_u64(0);
+                        let __v_105: G = G::from_u64(107);
+                        let __v_106: G = G::from_u64(0);
+                        let __v_107: G = G::from_u64(47);
+                        let __v_108: G = G::from_u64(0);
+                        let __v_109: G = G::from_u64(118);
+                        let __v_110: G = G::from_u64(0);
+                        let __v_111: G = G::from_u64(48);
+                        let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __v_126: G = G::from_u64(1);
+                        let __v_127: G = G::from_u64(1);
+                        let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_125, __v_128]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_129: G = __r_arr[0];
+                        let __v_130: G = __r_arr[1];
+                        let __v_131: G = __r_arr[2];
+                        let __v_132: G = __r_arr[3];
+                        let __v_133: G = __r_arr[4];
+                        let __v_134: G = __r_arr[5];
+                        let __v_135: G = __r_arr[6];
+                        let __v_136: G = __r_arr[7];
+                        let __v_137: G = __r_arr[8];
+                        let __v_138: G = __r_arr[9];
+                        let __v_139: G = __r_arr[10];
+                        let __v_140: G = __r_arr[11];
+                        let __v_141: G = __r_arr[12];
+                        let __v_142: G = __r_arr[13];
+                        let __v_143: G = __r_arr[14];
+                        let __v_144: G = __r_arr[15];
+                        let __v_145: G = __r_arr[16];
+                        let __v_146: G = __r_arr[17];
+                        let __v_147: G = G::from_u64(1);
+                        let __v_148: G = G::from_u64(1);
+                        let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_150: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_151: G = __r_arr[0];
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_145, __v_151]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_152: G = __r_arr[0];
+                        let __v_153: G = G::from_u64(1);
+                        let __v_154: G = G::from_u64(1);
+                        let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_152, __v_155]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_156: G = __r_arr[0];
+                        let __v_157: G = __r_arr[1];
+                        let __v_158: G = __r_arr[2];
+                        let __v_159: G = __r_arr[3];
+                        let __v_160: G = __r_arr[4];
+                        let __v_161: G = __r_arr[5];
+                        let __v_162: G = __r_arr[6];
+                        let __v_163: G = __r_arr[7];
+                        let __v_164: G = __r_arr[8];
+                        let __v_165: G = __r_arr[9];
+                        let __v_166: G = __r_arr[10];
+                        let __v_167: G = __r_arr[11];
+                        let __v_168: G = __r_arr[12];
+                        let __v_169: G = __r_arr[13];
+                        let __v_170: G = __r_arr[14];
+                        let __v_171: G = __r_arr[15];
+                        let __v_172: G = __r_arr[16];
+                        let __v_173: G = __r_arr[17];
+                        let __v_174: G = G::from_u64(1);
+                        let __v_175: G = G::from_u64(1);
+                        let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_177: G = __r_arr[0];
+                        let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_178: G = __r_arr[0];
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_172, __v_178]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_179: G = __r_arr[0];
+                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_179, __v_22]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_180: G = __r_arr[0];
+                        let __v_181: G = G::from_u64(1);
+                        let __v_182: G = G::from_u64(1);
+                        let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_26, __v_183]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_184: G = __r_arr[0];
+                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_180, __v_184]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_185: G = __r_arr[0];
+                        let __v_186: G = G::from_u64(1);
+                        let __v_187: G = G::from_u64(1);
+                        let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_185, __v_188]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_189: G = __r_arr[0];
+                        let __v_190: G = __r_arr[1];
+                        let __v_191: G = __r_arr[2];
+                        let __v_192: G = __r_arr[3];
+                        let __v_193: G = __r_arr[4];
+                        let __v_194: G = __r_arr[5];
+                        let __v_195: G = __r_arr[6];
+                        let __v_196: G = __r_arr[7];
+                        let __v_197: G = __r_arr[8];
+                        let __v_198: G = __r_arr[9];
+                        let __v_199: G = __r_arr[10];
+                        let __v_200: G = __r_arr[11];
+                        let __v_201: G = __r_arr[12];
+                        let __v_202: G = __r_arr[13];
+                        let __v_203: G = __r_arr[14];
+                        let __v_204: G = __r_arr[15];
+                        let __v_205: G = __r_arr[16];
+                        let __v_206: G = __r_arr[17];
+                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_205, __v_24]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_207: G = __r_arr[0];
+                        let __v_208: G = G::from_u64(1);
+                        let __v_209: G = G::from_u64(1);
+                        let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_207, __v_210]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_211: G = __r_arr[0];
+                        let __v_212: G = __r_arr[1];
+                        let __v_213: G = __r_arr[2];
+                        let __v_214: G = __r_arr[3];
+                        let __v_215: G = __r_arr[4];
+                        let __v_216: G = __r_arr[5];
+                        let __v_217: G = __r_arr[6];
+                        let __v_218: G = __r_arr[7];
+                        let __v_219: G = __r_arr[8];
+                        let __v_220: G = __r_arr[9];
+                        let __v_221: G = __r_arr[10];
+                        let __v_222: G = __r_arr[11];
+                        let __v_223: G = __r_arr[12];
+                        let __v_224: G = __r_arr[13];
+                        let __v_225: G = __r_arr[14];
+                        let __v_226: G = __r_arr[15];
+                        let __v_227: G = __r_arr[16];
+                        let __v_228: G = __r_arr[17];
+                        let __v_229: G = G::from_u64(256);
+                        let __v_230: G = (__v_229 * __v_130);
+                        let __v_231: G = G::from_u64(65536);
+                        let __v_232: G = (__v_231 * __v_131);
+                        let __v_233: G = G::from_u64(16777216);
+                        let __v_234: G = (__v_233 * __v_132);
+                        let __v_235: G = G::from_u64(4294967296);
+                        let __v_236: G = (__v_235 * __v_133);
+                        let __v_237: G = G::from_u64(1099511627776);
+                        let __v_238: G = (__v_237 * __v_134);
+                        let __v_239: G = G::from_u64(281474976710656);
+                        let __v_240: G = (__v_239 * __v_135);
+                        let __v_241: G = G::from_u64(72057594037927936);
+                        let __v_242: G = (__v_241 * __v_136);
+                        let __v_243: G = (__v_240 + __v_242);
+                        let __v_244: G = (__v_238 + __v_243);
+                        let __v_245: G = (__v_236 + __v_244);
+                        let __v_246: G = (__v_234 + __v_245);
+                        let __v_247: G = (__v_232 + __v_246);
+                        let __v_248: G = (__v_230 + __v_247);
+                        let __v_249: G = (__v_129 + __v_248);
+                        let __v_250: G = G::from_u64(256);
+                        let __v_251: G = (__v_250 * __v_138);
+                        let __v_252: G = G::from_u64(65536);
+                        let __v_253: G = (__v_252 * __v_139);
+                        let __v_254: G = G::from_u64(16777216);
+                        let __v_255: G = (__v_254 * __v_140);
+                        let __v_256: G = G::from_u64(4294967296);
+                        let __v_257: G = (__v_256 * __v_141);
+                        let __v_258: G = G::from_u64(1099511627776);
+                        let __v_259: G = (__v_258 * __v_142);
+                        let __v_260: G = G::from_u64(281474976710656);
+                        let __v_261: G = (__v_260 * __v_143);
+                        let __v_262: G = G::from_u64(72057594037927936);
+                        let __v_263: G = (__v_262 * __v_144);
+                        let __v_264: G = (__v_261 + __v_263);
+                        let __v_265: G = (__v_259 + __v_264);
+                        let __v_266: G = (__v_257 + __v_265);
+                        let __v_267: G = (__v_255 + __v_266);
+                        let __v_268: G = (__v_253 + __v_267);
+                        let __v_269: G = (__v_251 + __v_268);
+                        let __v_270: G = (__v_137 + __v_269);
+                        let __v_271: G = G::from_u64(256);
+                        let __v_272: G = (__v_271 * __v_157);
+                        let __v_273: G = G::from_u64(65536);
+                        let __v_274: G = (__v_273 * __v_158);
+                        let __v_275: G = G::from_u64(16777216);
+                        let __v_276: G = (__v_275 * __v_159);
+                        let __v_277: G = G::from_u64(4294967296);
+                        let __v_278: G = (__v_277 * __v_160);
+                        let __v_279: G = G::from_u64(1099511627776);
+                        let __v_280: G = (__v_279 * __v_161);
+                        let __v_281: G = G::from_u64(281474976710656);
+                        let __v_282: G = (__v_281 * __v_162);
+                        let __v_283: G = G::from_u64(72057594037927936);
+                        let __v_284: G = (__v_283 * __v_163);
+                        let __v_285: G = (__v_282 + __v_284);
+                        let __v_286: G = (__v_280 + __v_285);
+                        let __v_287: G = (__v_278 + __v_286);
+                        let __v_288: G = (__v_276 + __v_287);
+                        let __v_289: G = (__v_274 + __v_288);
+                        let __v_290: G = (__v_272 + __v_289);
+                        let __v_291: G = (__v_156 + __v_290);
+                        let __v_292: G = G::from_u64(256);
+                        let __v_293: G = (__v_292 * __v_165);
+                        let __v_294: G = G::from_u64(65536);
+                        let __v_295: G = (__v_294 * __v_166);
+                        let __v_296: G = G::from_u64(16777216);
+                        let __v_297: G = (__v_296 * __v_167);
+                        let __v_298: G = G::from_u64(4294967296);
+                        let __v_299: G = (__v_298 * __v_168);
+                        let __v_300: G = G::from_u64(1099511627776);
+                        let __v_301: G = (__v_300 * __v_169);
+                        let __v_302: G = G::from_u64(281474976710656);
+                        let __v_303: G = (__v_302 * __v_170);
+                        let __v_304: G = G::from_u64(72057594037927936);
+                        let __v_305: G = (__v_304 * __v_171);
+                        let __v_306: G = (__v_303 + __v_305);
+                        let __v_307: G = (__v_301 + __v_306);
+                        let __v_308: G = (__v_299 + __v_307);
+                        let __v_309: G = (__v_297 + __v_308);
+                        let __v_310: G = (__v_295 + __v_309);
+                        let __v_311: G = (__v_293 + __v_310);
+                        let __v_312: G = (__v_164 + __v_311);
+                        let __v_313: G = G::from_u64(256);
+                        let __v_314: G = (__v_313 * __v_190);
+                        let __v_315: G = G::from_u64(65536);
+                        let __v_316: G = (__v_315 * __v_191);
+                        let __v_317: G = G::from_u64(16777216);
+                        let __v_318: G = (__v_317 * __v_192);
+                        let __v_319: G = G::from_u64(4294967296);
+                        let __v_320: G = (__v_319 * __v_193);
+                        let __v_321: G = G::from_u64(1099511627776);
+                        let __v_322: G = (__v_321 * __v_194);
+                        let __v_323: G = G::from_u64(281474976710656);
+                        let __v_324: G = (__v_323 * __v_195);
+                        let __v_325: G = G::from_u64(72057594037927936);
+                        let __v_326: G = (__v_325 * __v_196);
+                        let __v_327: G = (__v_324 + __v_326);
+                        let __v_328: G = (__v_322 + __v_327);
+                        let __v_329: G = (__v_320 + __v_328);
+                        let __v_330: G = (__v_318 + __v_329);
+                        let __v_331: G = (__v_316 + __v_330);
+                        let __v_332: G = (__v_314 + __v_331);
+                        let __v_333: G = (__v_189 + __v_332);
+                        let __v_334: G = G::from_u64(256);
+                        let __v_335: G = (__v_334 * __v_198);
+                        let __v_336: G = G::from_u64(65536);
+                        let __v_337: G = (__v_336 * __v_199);
+                        let __v_338: G = G::from_u64(16777216);
+                        let __v_339: G = (__v_338 * __v_200);
+                        let __v_340: G = G::from_u64(4294967296);
+                        let __v_341: G = (__v_340 * __v_201);
+                        let __v_342: G = G::from_u64(1099511627776);
+                        let __v_343: G = (__v_342 * __v_202);
+                        let __v_344: G = G::from_u64(281474976710656);
+                        let __v_345: G = (__v_344 * __v_203);
+                        let __v_346: G = G::from_u64(72057594037927936);
+                        let __v_347: G = (__v_346 * __v_204);
+                        let __v_348: G = (__v_345 + __v_347);
+                        let __v_349: G = (__v_343 + __v_348);
+                        let __v_350: G = (__v_341 + __v_349);
+                        let __v_351: G = (__v_339 + __v_350);
+                        let __v_352: G = (__v_337 + __v_351);
+                        let __v_353: G = (__v_335 + __v_352);
+                        let __v_354: G = (__v_197 + __v_353);
+                        let __v_355: G = G::from_u64(256);
+                        let __v_356: G = (__v_355 * __v_212);
+                        let __v_357: G = G::from_u64(65536);
+                        let __v_358: G = (__v_357 * __v_213);
+                        let __v_359: G = G::from_u64(16777216);
+                        let __v_360: G = (__v_359 * __v_214);
+                        let __v_361: G = G::from_u64(4294967296);
+                        let __v_362: G = (__v_361 * __v_215);
+                        let __v_363: G = G::from_u64(1099511627776);
+                        let __v_364: G = (__v_363 * __v_216);
+                        let __v_365: G = G::from_u64(281474976710656);
+                        let __v_366: G = (__v_365 * __v_217);
+                        let __v_367: G = G::from_u64(72057594037927936);
+                        let __v_368: G = (__v_367 * __v_218);
+                        let __v_369: G = (__v_366 + __v_368);
+                        let __v_370: G = (__v_364 + __v_369);
+                        let __v_371: G = (__v_362 + __v_370);
+                        let __v_372: G = (__v_360 + __v_371);
+                        let __v_373: G = (__v_358 + __v_372);
+                        let __v_374: G = (__v_356 + __v_373);
+                        let __v_375: G = (__v_211 + __v_374);
+                        let __v_376: G = G::from_u64(256);
+                        let __v_377: G = (__v_376 * __v_220);
+                        let __v_378: G = G::from_u64(65536);
+                        let __v_379: G = (__v_378 * __v_221);
+                        let __v_380: G = G::from_u64(16777216);
+                        let __v_381: G = (__v_380 * __v_222);
+                        let __v_382: G = G::from_u64(4294967296);
+                        let __v_383: G = (__v_382 * __v_223);
+                        let __v_384: G = G::from_u64(1099511627776);
+                        let __v_385: G = (__v_384 * __v_224);
+                        let __v_386: G = G::from_u64(281474976710656);
+                        let __v_387: G = (__v_386 * __v_225);
+                        let __v_388: G = G::from_u64(72057594037927936);
+                        let __v_389: G = (__v_388 * __v_226);
+                        let __v_390: G = (__v_387 + __v_389);
+                        let __v_391: G = (__v_385 + __v_390);
+                        let __v_392: G = (__v_383 + __v_391);
+                        let __v_393: G = (__v_381 + __v_392);
+                        let __v_394: G = (__v_379 + __v_393);
+                        let __v_395: G = (__v_377 + __v_394);
+                        let __v_396: G = (__v_219 + __v_395);
+                        let __v_397: G = G::from_u64(0);
+                        let __v_398: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_399: G = __r_arr[0];
+                        let __v_400: G = __r_arr[1];
+                        let __v_401: G = G::from_u64(0);
+                        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_402: G = __r_arr[0];
+                        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_403: G = __r_arr[0];
+                        match __v_34.as_canonical_u64() {
+                          _ => {
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_34]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_404: G = __r_arr[0];
+                            let __v_405: G = G::from_u64(1);
+                            let __v_406: G = G::from_u64(1);
+                            let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() {
   0u64 => {
-    break '__mc_1 [__v_368];
+    break '__mc_1 [__v_407];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_32, __v_368]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_369: G = __r_arr[0];
-    break '__mc_1 [__v_369];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_60, __v_407]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_408: G = __r_arr[0];
+    break '__mc_1 [__v_408];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
   },
 }
  };
-                        let __v_369: G = __mc_out___mc_1[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_30, __v_369]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                        let __v_370: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_34, __v_370]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                        let __v_371: G = __r_arr[0];
-                        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_33, __v_371]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                        let __v_372: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_188, __v_372]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                        let __v_373: G = __r_arr[0];
-                        let __v_374: G = G::from_u64(1);
-                        let __v_375: G = G::from_u64(1);
-                        let __v_376: G = { let __values: [G; 3] = [__v_374, __v_375, __v_375]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_373, __v_376]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                        let __v_377: G = __r_arr[0];
-                        let __v_378: G = __r_arr[1];
-                        let __v_379: G = __r_arr[2];
-                        let __v_380: G = __r_arr[3];
-                        let __v_381: G = __r_arr[4];
-                        let __v_382: G = __r_arr[5];
-                        let __v_383: G = __r_arr[6];
-                        let __v_384: G = __r_arr[7];
-                        let __v_385: G = __r_arr[8];
-                        let __v_386: G = __r_arr[9];
-                        let __v_387: G = __r_arr[10];
-                        let __v_388: G = __r_arr[11];
-                        let __v_389: G = __r_arr[12];
-                        let __v_390: G = __r_arr[13];
-                        let __v_391: G = __r_arr[14];
-                        let __v_392: G = __r_arr[15];
-                        let __v_393: G = __r_arr[16];
-                        let __v_394: G = __r_arr[17];
-                        let __v_395: G = G::from_u64(256);
-                        let __v_396: G = (__v_395 * __v_378);
-                        let __v_397: G = G::from_u64(65536);
-                        let __v_398: G = (__v_397 * __v_379);
-                        let __v_399: G = G::from_u64(16777216);
-                        let __v_400: G = (__v_399 * __v_380);
-                        let __v_401: G = G::from_u64(4294967296);
-                        let __v_402: G = (__v_401 * __v_381);
-                        let __v_403: G = G::from_u64(1099511627776);
-                        let __v_404: G = (__v_403 * __v_382);
-                        let __v_405: G = G::from_u64(281474976710656);
-                        let __v_406: G = (__v_405 * __v_383);
-                        let __v_407: G = G::from_u64(72057594037927936);
-                        let __v_408: G = (__v_407 * __v_384);
-                        let __v_409: G = (__v_406 + __v_408);
-                        let __v_410: G = (__v_404 + __v_409);
-                        let __v_411: G = (__v_402 + __v_410);
-                        let __v_412: G = (__v_400 + __v_411);
-                        let __v_413: G = (__v_398 + __v_412);
-                        let __v_414: G = (__v_396 + __v_413);
-                        let __v_415: G = (__v_377 + __v_414);
-                        let __v_416: G = G::from_u64(256);
-                        let __v_417: G = (__v_416 * __v_386);
-                        let __v_418: G = G::from_u64(65536);
-                        let __v_419: G = (__v_418 * __v_387);
-                        let __v_420: G = G::from_u64(16777216);
-                        let __v_421: G = (__v_420 * __v_388);
-                        let __v_422: G = G::from_u64(4294967296);
-                        let __v_423: G = (__v_422 * __v_389);
-                        let __v_424: G = G::from_u64(1099511627776);
-                        let __v_425: G = (__v_424 * __v_390);
-                        let __v_426: G = G::from_u64(281474976710656);
-                        let __v_427: G = (__v_426 * __v_391);
-                        let __v_428: G = G::from_u64(72057594037927936);
-                        let __v_429: G = (__v_428 * __v_392);
-                        let __v_430: G = (__v_427 + __v_429);
-                        let __v_431: G = (__v_425 + __v_430);
-                        let __v_432: G = (__v_423 + __v_431);
-                        let __v_433: G = (__v_421 + __v_432);
-                        let __v_434: G = (__v_419 + __v_433);
-                        let __v_435: G = (__v_417 + __v_434);
-                        let __v_436: G = (__v_385 + __v_435);
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_393, __v_18, __v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-                        let __v_437: G = __r_arr[0];
-                        let __v_438: G = __r_arr[1];
-                        let __v_439: G = G::from_u64(1);
-                        let __v_440: G = G::from_u64(1);
-                        let __v_441: G = { let __values: [G; 3] = [__v_439, __v_440, __v_440]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_21, __v_441]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                        let __v_442: G = __r_arr[0];
-                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_438, __v_442]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                        let __v_443: G = __r_arr[0];
-                        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_443, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-                        let __v_444: G = __r_arr[0];
-                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_444, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-                        let __v_445: G = __r_arr[0];
-                        let __v_446: G = __r_arr[1];
-                        let __v_447: G = (__v_365 + __v_0);
-                        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
-                        let __v_448: G = __r_arr[0];
-                        let __v_449: G = G::from_u64(1);
-                        if (__v_448 != __v_449) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_448.as_canonical_u64(), rhs: __v_449.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                        let __v_450: G = __r_arr[0];
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                        let __v_451: G = __r_arr[0];
-                        let __v_452: G = (__v_450 - __v_451);
-                        let __v_453: G = G::from_bool((__v_452 == G::ZERO));
-                        let __v_454: G = G::from_u64(1);
-                        if (__v_453 != __v_454) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                        let __v_455: G = __r_arr[0];
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_456: G = __r_arr[0];
-                        let __v_457: G = (__v_455 - __v_456);
-                        let __v_458: G = G::from_bool((__v_457 == G::ZERO));
-                        let __v_459: G = G::from_u64(1);
-                        if (__v_458 != __v_459) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_458.as_canonical_u64(), rhs: __v_459.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-                        let __v_460: G = __r_arr[0];
-                        let __v_461: G = (__v_460 - __v_365);
-                        let __v_462: G = G::from_bool((__v_461 == G::ZERO));
-                        let __v_463: G = G::from_u64(1);
-                        if (__v_462 != __v_463) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_463.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_464: G = __r_arr[0];
-                        let __v_465: G = (__v_464 - __v_4);
-                        let __v_466: G = G::from_bool((__v_465 == G::ZERO));
-                        let __v_467: G = G::from_u64(1);
-                        if (__v_466 != __v_467) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None });
-                        }
-                        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                        let __v_468: G = __r_arr[0];
-                        let __v_469: G = G::from_u64(1);
-                        if (__v_468 != __v_469) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_468.as_canonical_u64(), rhs: __v_469.as_canonical_u64(), msg: None });
-                        }
-                        let __v_470: G = G::from_u64(33);
-                        let __v_471: G = { let __a_val = __v_447.as_canonical_u64(); let __b_val = __v_470.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                        let __v_472: G = G::from_u64(1);
-                        if (__v_471 != __v_472) {
-                          return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_472.as_canonical_u64(), msg: None });
+                            let __v_408: G = __mc_out___mc_1[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_57, __v_408]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_409: G = __r_arr[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_409]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_410: G = __r_arr[0];
+                            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_62, __v_410]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_411: G = __r_arr[0];
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_227, __v_411]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_412: G = __r_arr[0];
+                            let __v_413: G = G::from_u64(1);
+                            let __v_414: G = G::from_u64(1);
+                            let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_412, __v_415]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_416: G = __r_arr[0];
+                            let __v_417: G = __r_arr[1];
+                            let __v_418: G = __r_arr[2];
+                            let __v_419: G = __r_arr[3];
+                            let __v_420: G = __r_arr[4];
+                            let __v_421: G = __r_arr[5];
+                            let __v_422: G = __r_arr[6];
+                            let __v_423: G = __r_arr[7];
+                            let __v_424: G = __r_arr[8];
+                            let __v_425: G = __r_arr[9];
+                            let __v_426: G = __r_arr[10];
+                            let __v_427: G = __r_arr[11];
+                            let __v_428: G = __r_arr[12];
+                            let __v_429: G = __r_arr[13];
+                            let __v_430: G = __r_arr[14];
+                            let __v_431: G = __r_arr[15];
+                            let __v_432: G = __r_arr[16];
+                            let __v_433: G = __r_arr[17];
+                            let __v_434: G = G::from_u64(256);
+                            let __v_435: G = (__v_434 * __v_417);
+                            let __v_436: G = G::from_u64(65536);
+                            let __v_437: G = (__v_436 * __v_418);
+                            let __v_438: G = G::from_u64(16777216);
+                            let __v_439: G = (__v_438 * __v_419);
+                            let __v_440: G = G::from_u64(4294967296);
+                            let __v_441: G = (__v_440 * __v_420);
+                            let __v_442: G = G::from_u64(1099511627776);
+                            let __v_443: G = (__v_442 * __v_421);
+                            let __v_444: G = G::from_u64(281474976710656);
+                            let __v_445: G = (__v_444 * __v_422);
+                            let __v_446: G = G::from_u64(72057594037927936);
+                            let __v_447: G = (__v_446 * __v_423);
+                            let __v_448: G = (__v_445 + __v_447);
+                            let __v_449: G = (__v_443 + __v_448);
+                            let __v_450: G = (__v_441 + __v_449);
+                            let __v_451: G = (__v_439 + __v_450);
+                            let __v_452: G = (__v_437 + __v_451);
+                            let __v_453: G = (__v_435 + __v_452);
+                            let __v_454: G = (__v_416 + __v_453);
+                            let __v_455: G = G::from_u64(256);
+                            let __v_456: G = (__v_455 * __v_425);
+                            let __v_457: G = G::from_u64(65536);
+                            let __v_458: G = (__v_457 * __v_426);
+                            let __v_459: G = G::from_u64(16777216);
+                            let __v_460: G = (__v_459 * __v_427);
+                            let __v_461: G = G::from_u64(4294967296);
+                            let __v_462: G = (__v_461 * __v_428);
+                            let __v_463: G = G::from_u64(1099511627776);
+                            let __v_464: G = (__v_463 * __v_429);
+                            let __v_465: G = G::from_u64(281474976710656);
+                            let __v_466: G = (__v_465 * __v_430);
+                            let __v_467: G = G::from_u64(72057594037927936);
+                            let __v_468: G = (__v_467 * __v_431);
+                            let __v_469: G = (__v_466 + __v_468);
+                            let __v_470: G = (__v_464 + __v_469);
+                            let __v_471: G = (__v_462 + __v_470);
+                            let __v_472: G = (__v_460 + __v_471);
+                            let __v_473: G = (__v_458 + __v_472);
+                            let __v_474: G = (__v_456 + __v_473);
+                            let __v_475: G = (__v_424 + __v_474);
+                            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_432, __v_34, __v_36, __v_5]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_476: G = __r_arr[0];
+                            let __v_477: G = __r_arr[1];
+                            let __v_478: G = G::from_u64(1);
+                            let __v_479: G = G::from_u64(1);
+                            let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_46, __v_480]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_481: G = __r_arr[0];
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_477, __v_481]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_482: G = __r_arr[0];
+                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_482, __v_34]; 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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_483: G = __r_arr[0];
+                            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_484: G = __r_arr[0];
+                            let __v_485: G = __r_arr[1];
+                            let __v_486: G = (__v_404 + __v_0);
+                            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_4, __v_486]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_487: G = __r_arr[0];
+                            let __v_488: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_40, __v_44, __v_488, __v_4]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_489: G = __r_arr[0];
+                            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_490: G = __r_arr[0];
+                            let __v_491: G = (__v_14 + __v_15);
+                            if (__v_65 != __v_491) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_491.as_canonical_u64(), msg: None });
+                            }
+                            let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+                            let __v_492: G = __loaded[0];
+                            let __v_493: G = __loaded[1];
+                            let __v_494: G = __loaded[2];
+                            let __v_495: G = G::from_u64(1);
+                            let __v_496: G = G::from_u64(1);
+                            if (__v_492 != __v_495) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_492.as_canonical_u64(), rhs: __v_495.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_493 != __v_496) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_493.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: None });
+                            }
+                            if (__v_494 != __v_496) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_494.as_canonical_u64(), rhs: __v_496.as_canonical_u64(), msg: None });
+                            }
+                            let __v_497: G = G::from_bool((__v_75 == G::ZERO));
+                            let __v_498: G = G::from_u64(0);
+                            if (__v_497 != __v_498) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_497.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_62]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_499: G = __r_arr[0];
+                            if (__v_499 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_499.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_64]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_500: G = __r_arr[0];
+                            if (__v_500 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_500.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_57]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_501: G = __r_arr[0];
+                            if (__v_501 != __v_75) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_501.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_26]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_502: G = __r_arr[0];
+                            let __v_503: G = G::from_u64(1);
+                            if (__v_502 != __v_503) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_502.as_canonical_u64(), rhs: __v_503.as_canonical_u64(), msg: None });
+                            }
+                            let __v_504: G = G::from_u64(1);
+                            let __v_505: G = G::from_u64(1);
+                            if (__v_504 != __v_505) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_504.as_canonical_u64(), rhs: __v_505.as_canonical_u64(), msg: None });
+                            }
+                            let __v_506: G = G::from_u64(0);
+                            if (__v_1 != __v_506) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_506.as_canonical_u64(), msg: None });
+                            }
+                            let __v_507: G = G::from_u64(0);
+                            if (__v_2 != __v_507) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_507.as_canonical_u64(), msg: None });
+                            }
+                            let __v_508: G = G::from_u64(1);
+                            if (__v_3 != __v_508) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_508.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_18]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_509: G = __r_arr[0];
+                            let __v_510: G = G::from_u64(1);
+                            if (__v_509 != __v_510) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_510.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_18]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_511: G = __r_arr[0];
+                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_512: G = __r_arr[0];
+                            let __v_513: G = (__v_511 - __v_512);
+                            let __v_514: G = G::from_bool((__v_513 == G::ZERO));
+                            let __v_515: G = G::from_u64(1);
+                            if (__v_514 != __v_515) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_516: G = __r_arr[0];
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_26]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_517: G = __r_arr[0];
+                            let __v_518: G = (__v_516 - __v_517);
+                            let __v_519: G = G::from_bool((__v_518 == G::ZERO));
+                            let __v_520: G = G::from_u64(1);
+                            if (__v_519 != __v_520) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_519.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_36]; 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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_521: G = __r_arr[0];
+                            let __v_522: G = (__v_521 - __v_404);
+                            let __v_523: G = G::from_bool((__v_522 == G::ZERO));
+                            let __v_524: G = G::from_u64(1);
+                            if (__v_523 != __v_524) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_524.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_40]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_525: G = __r_arr[0];
+                            let __v_526: G = G::from_u64(3);
+                            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_59, __v_60]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_527: G = __r_arr[0];
+                            let __v_528: G = (__v_526 + __v_527);
+                            if (__v_525 != __v_528) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_528.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_44]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_529: G = __r_arr[0];
+                            let __v_530: G = (__v_529 - __v_404);
+                            let __v_531: G = G::from_bool((__v_530 == G::ZERO));
+                            let __v_532: G = G::from_u64(1);
+                            if (__v_531 != __v_532) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_531.as_canonical_u64(), rhs: __v_532.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_46]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_533: G = __r_arr[0];
+                            let __v_534: G = G::from_u64(1);
+                            if (__v_533 != __v_534) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_533.as_canonical_u64(), rhs: __v_534.as_canonical_u64(), msg: None });
+                            }
+                            let __v_535: G = G::from_u64(33);
+                            let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                            let __v_537: G = G::from_u64(1);
+                            if (__v_536 != __v_537) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_536.as_canonical_u64(), rhs: __v_537.as_canonical_u64(), msg: None });
+                            }
+                            let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_538: G = __r_arr[0];
+                            let __v_539: G = G::from_u64(1);
+                            if (__v_538 != __v_539) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_538.as_canonical_u64(), rhs: __v_539.as_canonical_u64(), msg: None });
+                            }
+                            let __v_540: G = G::from_u64(0);
+                            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_541: G = __r_arr[0];
+                            let __v_542: G = G::from_u64(1);
+                            if (__v_541 != __v_542) {
+                              return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_542.as_canonical_u64(), msg: None });
+                            }
+                            let __ret: [G; OUT_236] = [__v_73];
+                            if !unconstrained { record.virt += record.function_queries[236].weight(); } record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+                            return Ok(__ret);
+                          },
                         }
-                        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_445, __v_446, __v_20, __v_415, __v_436, __v_33, __v_34, __v_30, __v_31, __v_32, __v_13, __v_14, __v_15, __v_39, __v_38, __v_17, __v_336, __v_357, __v_364, __v_0, __v_447, __v_437, __v_18, __v_21, __v_365]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-                        let __v_473: G = __r_arr[0];
-                        let __ret: [G; OUT_183] = [__v_473];
-                        if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                        return Ok(__ret);
                       },
                     }
                   },
@@ -17876,327 +23371,2176 @@ fn aiur_fn_183(
   })
 }
 
-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_237: usize = 2;
+const IN_237: usize = 2;
+const OUT_237: usize = 3;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_184] = [__v_4];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __v_5: G = (__v_2 - __v_4);
-        let __v_6: G = (__v_2 * __v_5);
-        let __v_7: G = G::from_u64(0);
-        if (__v_6 != __v_7) {
-          return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
-        }
-        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_184] = [__v_8];
-        if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
+    let __v_1: G = inp[1];
+    let __v_2: G = G::from_u64(10);
+    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_2]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_3: G = __r_arr[0];
+    let __v_4: G = __r_arr[1];
+    let __v_5: G = __r_arr[2];
+    let __v_6: G = __r_arr[3];
+    let __v_7: G = __r_arr[4];
+    let __v_8: G = __r_arr[5];
+    let __v_9: G = __r_arr[6];
+    let __v_10: G = __r_arr[7];
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_11: G = __r_arr[0];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_12: G = __r_arr[0];
+    let __v_13: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_13, __v_12]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_14]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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_16: G = __r_arr[0];
+    let __v_17: G = G::from_u64(2);
+    let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_17]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_26: G = __loaded[0];
+    let __v_27: G = __loaded[1];
+    let __v_28: G = __loaded[2];
+    let __v_29: G = G::from_u64(1);
+    let __v_30: G = G::from_u64(1);
+    if (__v_26 != __v_29) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: None });
+    }
+    if (__v_27 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+    }
+    if (__v_28 != __v_30) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_31: G = __r_arr[0];
+    let __v_32: G = G::from_u64(10);
+    if (__v_31 != __v_32) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("join: IxVM lift must expose a 10-word verify_claim claim".to_string()) });
+    }
+    let __v_33: G = G::from_u64(0);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_16, __v_33]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+    let __v_35: G = G::from_u64(0);
+    if (__v_34 != __v_35) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("join: IxVM child has the wrong claim channel".to_string()) });
+    }
+    let __v_36: G = G::from_u64(1);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_16, __v_36]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_37: G = __r_arr[0];
+    if (__v_37 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: IxVM child has the wrong entrypoint".to_string()) });
     }
+    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_38]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_39: G = __r_arr[0];
+    let __v_40: G = __r_arr[1];
+    let __v_41: G = __r_arr[2];
+    let __ret: [G; OUT_237] = [__v_39, __v_40, __v_41];
+    if !unconstrained { record.virt += record.function_queries[237].weight(); } record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_185: usize = 2;
-const IN_185: usize = 2;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_238: usize = 21;
+const IN_238: usize = 21;
+const OUT_238: usize = 3;
+fn aiur_fn_238(
+  inp: [G; IN_238],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_238], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    let __v_6: G = __loaded[4];
-    let __v_7: G = __loaded[5];
-    let __v_8: G = __loaded[6];
-    let __v_9: G = __loaded[7];
-    match __v_2.as_canonical_u64() {
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = inp[16];
+    let __v_17: G = inp[17];
+    let __v_18: G = inp[18];
+    let __v_19: G = inp[19];
+    let __v_20: G = inp[20];
+    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_0]; 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 { let __r = record.function_queries[235].replay_at(__i); record.virt += __r; } 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_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(1);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_21, __v_22]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_23: G = __r_arr[0];
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_21]; 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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_24: G = __r_arr[0];
+    let __v_25: G = G::from_u64(18);
+    if (__v_24 != __v_25) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("join: recursive child claim must contain 16 public inputs".to_string()) });
+    }
+    let __v_26: G = G::from_u64(0);
+    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_21, __v_26]; 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 { let __r = record.function_queries[232].replay_at(__i); record.virt += __r; } 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_27: G = __r_arr[0];
+    let __v_28: G = G::from_u64(0);
+    if (__v_27 != __v_28) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("join: recursive child has the wrong claim channel".to_string()) });
+    }
+    let __v_29: G = (__v_23 - __v_18);
+    let __v_30: G = G::from_bool((__v_29 == G::ZERO));
+    match __v_30.as_canonical_u64() {
       1u64 => {
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_185] = [__v_12];
-        if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_31: G = G::from_u64(2);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_31]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_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 __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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_237] = { let __args: [G; IN_237] = [__v_21, __v_17]; 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 { let __r = record.function_queries[237].replay_at(__i); record.virt += __r; } 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_40: G = __r_arr[0];
+        let __v_41: G = __r_arr[1];
+        let __v_42: G = __r_arr[2];
+        let __ret: [G; OUT_238] = [__v_40, __v_41, __v_42];
+        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_10: G = __loaded[0];
-        let __v_11: G = __loaded[1];
-        let __v_12: G = __loaded[2];
-        match __v_10.as_canonical_u64() {
-          0u64 => {
-            match __v_11.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-                let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_185] = [__v_13];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-                let __v_14: G = __r_arr[0];
-                let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_185] = [__v_15];
-                if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        let __v_31: G = (__v_23 - __v_19);
+        let __v_32: G = G::from_bool((__v_31 == G::ZERO));
+        let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_32.as_canonical_u64() {
+  1u64 => {
+    break '__mc_0 [];
+  },
+  _ => {
+    if (__v_23 != __v_20) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("join: child is neither lift, flat join, nor structural join".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+}
+ };
+        let __v_33: G = G::from_u64(2);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_33]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
+        let __v_35: G = __r_arr[1];
+        let __v_36: G = __r_arr[2];
+        let __v_37: G = __r_arr[3];
+        let __v_38: G = __r_arr[4];
+        let __v_39: G = __r_arr[5];
+        let __v_40: G = __r_arr[6];
+        let __v_41: G = __r_arr[7];
+        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; 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 { let __r = record.function_queries[234].replay_at(__i); record.virt += __r; } 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_42: G = G::from_u64(10);
+        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_42]; 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 { let __r = record.function_queries[233].replay_at(__i); record.virt += __r; } 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_43: G = __r_arr[0];
+        let __v_44: G = __r_arr[1];
+        let __v_45: G = __r_arr[2];
+        let __v_46: G = __r_arr[3];
+        let __v_47: G = __r_arr[4];
+        let __v_48: G = __r_arr[5];
+        let __v_49: G = __r_arr[6];
+        let __v_50: G = __r_arr[7];
+        let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; 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 { let __r = record.function_queries[231].replay_at(__i); record.virt += __r; } 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_51: G = __r_arr[0];
+        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_51]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_52: G = __r_arr[0];
+        let __v_53: G = __r_arr[1];
+        let __v_54: G = __r_arr[2];
+        let __ret: [G; OUT_238] = [__v_52, __v_53, __v_54];
+        if !unconstrained { record.virt += record.function_queries[238].weight(); } record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_186: usize = 2;
-const IN_186: usize = 2;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_239: usize = 16;
+const IN_239: usize = 16;
+const OUT_239: usize = 0;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    let __v_5: G = __loaded[3];
-    match __v_2.as_canonical_u64() {
-      1u64 => {
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = G::from_u64(1);
-        let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_186] = [__v_8];
-        if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-        let __v_6: G = __loaded[0];
-        let __v_7: G = __loaded[1];
-        let __v_8: G = __loaded[2];
-        match __v_6.as_canonical_u64() {
-          0u64 => {
-            match __v_7.as_canonical_u64() {
-              0u64 => {
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-                let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_186] = [__v_9];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-              _ => {
-                let __v_9: G = G::from_u64(0);
-                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-                let __v_10: G = __r_arr[0];
-                let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_186] = [__v_11];
-                if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-                return Ok(__ret);
-              },
-            }
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = G::from_u64(3);
+    let __v_17: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_18: G = __io_pair.0;
+    let __v_19: G = __io_pair.1;
+    let __v_20: G = G::from_u64(3);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; 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_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(103);
+    let __v_23: G = G::from_u64(230);
+    let __v_24: G = G::from_u64(9);
+    let __v_25: G = G::from_u64(106);
+    let __v_26: G = G::from_u64(133);
+    let __v_27: G = G::from_u64(174);
+    let __v_28: G = G::from_u64(103);
+    let __v_29: G = G::from_u64(187);
+    let __v_30: G = G::from_u64(114);
+    let __v_31: G = G::from_u64(243);
+    let __v_32: G = G::from_u64(110);
+    let __v_33: G = G::from_u64(60);
+    let __v_34: G = G::from_u64(58);
+    let __v_35: G = G::from_u64(245);
+    let __v_36: G = G::from_u64(79);
+    let __v_37: G = G::from_u64(165);
+    let __v_38: G = G::from_u64(127);
+    let __v_39: G = G::from_u64(82);
+    let __v_40: G = G::from_u64(14);
+    let __v_41: G = G::from_u64(81);
+    let __v_42: G = G::from_u64(140);
+    let __v_43: G = G::from_u64(104);
+    let __v_44: G = G::from_u64(5);
+    let __v_45: G = G::from_u64(155);
+    let __v_46: G = G::from_u64(171);
+    let __v_47: G = G::from_u64(217);
+    let __v_48: G = G::from_u64(131);
+    let __v_49: G = G::from_u64(31);
+    let __v_50: G = G::from_u64(25);
+    let __v_51: G = G::from_u64(205);
+    let __v_52: G = G::from_u64(224);
+    let __v_53: G = G::from_u64(91);
+    let __v_54: G = G::from_u64(1);
+    let __v_55: G = G::from_u64(1);
+    let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = G::from_u64(0);
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = G::from_u64(1);
+    let __v_70: G = G::from_u64(1);
+    let __v_71: G = { let __values: [G; 34] = [__v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    let __v_75: G = __r_arr[2];
+    let __v_76: G = __r_arr[3];
+    let __v_77: G = __r_arr[4];
+    let __v_78: G = __r_arr[5];
+    let __v_79: G = __r_arr[6];
+    let __v_80: G = __r_arr[7];
+    let __v_81: G = __r_arr[8];
+    let __v_82: G = __r_arr[9];
+    let __v_83: G = __r_arr[10];
+    let __v_84: G = __r_arr[11];
+    let __v_85: G = __r_arr[12];
+    let __v_86: G = __r_arr[13];
+    let __v_87: G = __r_arr[14];
+    let __v_88: G = __r_arr[15];
+    let __v_89: G = __r_arr[16];
+    let __v_90: G = __r_arr[17];
+    let __v_91: G = __r_arr[18];
+    let __v_92: G = __r_arr[19];
+    let __v_93: G = __r_arr[20];
+    let __v_94: G = __r_arr[21];
+    let __v_95: G = __r_arr[22];
+    let __v_96: G = __r_arr[23];
+    let __v_97: G = __r_arr[24];
+    let __v_98: G = __r_arr[25];
+    let __v_99: G = __r_arr[26];
+    let __v_100: G = __r_arr[27];
+    let __v_101: G = __r_arr[28];
+    let __v_102: G = __r_arr[29];
+    let __v_103: G = __r_arr[30];
+    let __v_104: G = __r_arr[31];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_21]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_122]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_143: G = __r_arr[0];
+    let __v_144: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_145: G = __r_arr[0];
+    let __v_146: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_147: G = __r_arr[0];
+    let __v_148: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_149: G = __r_arr[0];
+    let __v_150: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_153: G = __r_arr[0];
+    let __v_154: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_155: G = __r_arr[0];
+    let __v_156: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_157: G = __r_arr[0];
+    let __v_158: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_161: G = __r_arr[0];
+    let __v_162: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_163: G = __r_arr[0];
+    let __v_164: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_165: G = __r_arr[0];
+    let __v_166: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_167: G = __r_arr[0];
+    let __v_168: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_171: G = __r_arr[0];
+    let __v_172: G = __r_arr[1];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_105]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_173: G = __r_arr[0];
+    let __v_174: G = __r_arr[1];
+    let __v_175: G = __r_arr[2];
+    let __v_176: G = __r_arr[3];
+    let __v_177: G = __r_arr[4];
+    let __v_178: G = __r_arr[5];
+    let __v_179: G = __r_arr[6];
+    let __v_180: G = __r_arr[7];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_123]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_181: G = __r_arr[0];
+    let __v_182: G = __r_arr[1];
+    let __v_183: G = __r_arr[2];
+    let __v_184: G = __r_arr[3];
+    let __v_185: G = __r_arr[4];
+    let __v_186: G = __r_arr[5];
+    let __v_187: G = __r_arr[6];
+    let __v_188: G = __r_arr[7];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_189: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_190: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_191: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_192: G = __r_arr[0];
+    let __v_193: G = G::from_u64(1);
+    let __v_194: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_194]; let __info = io_buffer.get_info(__v_193, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_195: G = __io_pair.0;
+    let __v_196: G = __io_pair.1;
+    let __v_197: G = G::from_u64(1);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; 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_198: G = __r_arr[0];
+    let __v_199: G = G::from_u64(103);
+    let __v_200: G = G::from_u64(230);
+    let __v_201: G = G::from_u64(9);
+    let __v_202: G = G::from_u64(106);
+    let __v_203: G = G::from_u64(133);
+    let __v_204: G = G::from_u64(174);
+    let __v_205: G = G::from_u64(103);
+    let __v_206: G = G::from_u64(187);
+    let __v_207: G = G::from_u64(114);
+    let __v_208: G = G::from_u64(243);
+    let __v_209: G = G::from_u64(110);
+    let __v_210: G = G::from_u64(60);
+    let __v_211: G = G::from_u64(58);
+    let __v_212: G = G::from_u64(245);
+    let __v_213: G = G::from_u64(79);
+    let __v_214: G = G::from_u64(165);
+    let __v_215: G = G::from_u64(127);
+    let __v_216: G = G::from_u64(82);
+    let __v_217: G = G::from_u64(14);
+    let __v_218: G = G::from_u64(81);
+    let __v_219: G = G::from_u64(140);
+    let __v_220: G = G::from_u64(104);
+    let __v_221: G = G::from_u64(5);
+    let __v_222: G = G::from_u64(155);
+    let __v_223: G = G::from_u64(171);
+    let __v_224: G = G::from_u64(217);
+    let __v_225: G = G::from_u64(131);
+    let __v_226: G = G::from_u64(31);
+    let __v_227: G = G::from_u64(25);
+    let __v_228: G = G::from_u64(205);
+    let __v_229: G = G::from_u64(224);
+    let __v_230: G = G::from_u64(91);
+    let __v_231: G = G::from_u64(1);
+    let __v_232: G = G::from_u64(1);
+    let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(0);
+    let __v_237: G = G::from_u64(0);
+    let __v_238: G = G::from_u64(0);
+    let __v_239: G = G::from_u64(0);
+    let __v_240: G = G::from_u64(0);
+    let __v_241: G = G::from_u64(0);
+    let __v_242: G = G::from_u64(0);
+    let __v_243: G = G::from_u64(0);
+    let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_245: G = { let __values: [G; 32] = [__v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_246: G = G::from_u64(1);
+    let __v_247: G = G::from_u64(1);
+    let __v_248: G = { let __values: [G; 34] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_198, __v_233, __v_234, __v_235, __v_244, __v_245, __v_248]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_249: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_250: G = __r_arr[0];
+    let __v_251: G = __r_arr[1];
+    let __v_252: G = __r_arr[2];
+    let __v_253: G = __r_arr[3];
+    let __v_254: G = __r_arr[4];
+    let __v_255: G = __r_arr[5];
+    let __v_256: G = __r_arr[6];
+    let __v_257: G = __r_arr[7];
+    let __v_258: G = __r_arr[8];
+    let __v_259: G = __r_arr[9];
+    let __v_260: G = __r_arr[10];
+    let __v_261: G = __r_arr[11];
+    let __v_262: G = __r_arr[12];
+    let __v_263: G = __r_arr[13];
+    let __v_264: G = __r_arr[14];
+    let __v_265: G = __r_arr[15];
+    let __v_266: G = __r_arr[16];
+    let __v_267: G = __r_arr[17];
+    let __v_268: G = __r_arr[18];
+    let __v_269: G = __r_arr[19];
+    let __v_270: G = __r_arr[20];
+    let __v_271: G = __r_arr[21];
+    let __v_272: G = __r_arr[22];
+    let __v_273: G = __r_arr[23];
+    let __v_274: G = __r_arr[24];
+    let __v_275: G = __r_arr[25];
+    let __v_276: G = __r_arr[26];
+    let __v_277: G = __r_arr[27];
+    let __v_278: G = __r_arr[28];
+    let __v_279: G = __r_arr[29];
+    let __v_280: G = __r_arr[30];
+    let __v_281: G = __r_arr[31];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_282: G = __r_arr[0];
+    let __v_283: G = __r_arr[1];
+    let __v_284: G = __r_arr[2];
+    let __v_285: G = __r_arr[3];
+    let __v_286: G = __r_arr[4];
+    let __v_287: G = __r_arr[5];
+    let __v_288: G = __r_arr[6];
+    let __v_289: G = __r_arr[7];
+    let __v_290: G = __r_arr[8];
+    let __v_291: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_292: G = __r_arr[0];
+    let __v_293: G = __r_arr[1];
+    let __v_294: G = __r_arr[2];
+    let __v_295: G = __r_arr[3];
+    let __v_296: G = __r_arr[4];
+    let __v_297: G = __r_arr[5];
+    let __v_298: G = __r_arr[6];
+    let __v_299: G = __r_arr[7];
+    let __v_300: G = __r_arr[8];
+    let __v_301: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_302: G = __r_arr[0];
+    let __v_303: G = __r_arr[1];
+    let __v_304: G = __r_arr[2];
+    let __v_305: G = __r_arr[3];
+    let __v_306: G = __r_arr[4];
+    let __v_307: G = __r_arr[5];
+    let __v_308: G = __r_arr[6];
+    let __v_309: G = __r_arr[7];
+    let __v_310: G = __r_arr[8];
+    let __v_311: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_312: G = __r_arr[0];
+    let __v_313: G = __r_arr[1];
+    let __v_314: G = __r_arr[2];
+    let __v_315: G = __r_arr[3];
+    let __v_316: G = __r_arr[4];
+    let __v_317: G = __r_arr[5];
+    let __v_318: G = __r_arr[6];
+    let __v_319: G = __r_arr[7];
+    let __v_320: G = __r_arr[8];
+    let __v_321: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_322: G = __r_arr[0];
+    let __v_323: G = __r_arr[1];
+    let __v_324: G = __r_arr[2];
+    let __v_325: G = __r_arr[3];
+    let __v_326: G = __r_arr[4];
+    let __v_327: G = __r_arr[5];
+    let __v_328: G = __r_arr[6];
+    let __v_329: G = __r_arr[7];
+    let __v_330: G = __r_arr[8];
+    let __v_331: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_332: G = __r_arr[0];
+    let __v_333: G = __r_arr[1];
+    let __v_334: G = __r_arr[2];
+    let __v_335: G = __r_arr[3];
+    let __v_336: G = __r_arr[4];
+    let __v_337: G = __r_arr[5];
+    let __v_338: G = __r_arr[6];
+    let __v_339: G = __r_arr[7];
+    let __v_340: G = __r_arr[8];
+    let __v_341: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_342: G = __r_arr[0];
+    let __v_343: G = __r_arr[1];
+    let __v_344: G = __r_arr[2];
+    let __v_345: G = __r_arr[3];
+    let __v_346: G = __r_arr[4];
+    let __v_347: G = __r_arr[5];
+    let __v_348: G = __r_arr[6];
+    let __v_349: G = __r_arr[7];
+    let __v_350: G = __r_arr[8];
+    let __v_351: G = __r_arr[9];
+    let __v_352: G = G::from_u64(0);
+    let __v_353: G = G::from_u64(0);
+    let __v_354: G = G::from_u64(0);
+    let __v_355: G = G::from_u64(0);
+    let __v_356: G = G::from_u64(0);
+    let __v_357: G = G::from_u64(0);
+    let __v_358: G = G::from_u64(0);
+    let __v_359: G = G::from_u64(1);
+    let __v_360: G = G::from_u64(1);
+    let __v_361: G = { let __values: [G; 10] = [__v_359, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_362: G = { let __values: [G; 10] = [__v_358, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_361]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_363: G = { let __values: [G; 10] = [__v_357, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_362]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_364: G = { let __values: [G; 10] = [__v_356, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_363]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_365: G = { let __values: [G; 10] = [__v_355, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_320, __v_364]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_366: G = { let __values: [G; 10] = [__v_354, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_365]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_367: G = { let __values: [G; 10] = [__v_353, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_366]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_368: G = { let __values: [G; 10] = [__v_352, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_367]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_369: G = __r_arr[0];
+    let __v_370: G = __r_arr[1];
+    let __v_371: G = __r_arr[2];
+    let __v_372: G = __r_arr[3];
+    let __v_373: G = __r_arr[4];
+    let __v_374: G = __r_arr[5];
+    let __v_375: G = __r_arr[6];
+    let __v_376: G = __r_arr[7];
+    let __v_377: G = __r_arr[8];
+    let __v_378: G = __r_arr[9];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_379: G = __r_arr[0];
+    let __v_380: G = __r_arr[1];
+    let __v_381: G = __r_arr[2];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_382: G = __r_arr[0];
+    let __v_383: G = __r_arr[1];
+    let __v_384: G = __r_arr[2];
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_385: G = __r_arr[0];
+    let __v_386: G = __r_arr[1];
+    let __v_387: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_387.as_canonical_u64().to_le_bytes();
+    let __v_388: G = G::from_u8(__gb[0]);
+    let __v_389: G = G::from_u8(__gb[1]);
+    let __v_390: G = G::from_u8(__gb[2]);
+    let __v_391: G = G::from_u8(__gb[3]);
+    let __v_392: G = G::from_u8(__gb[4]);
+    let __v_393: G = G::from_u8(__gb[5]);
+    let __v_394: G = G::from_u8(__gb[6]);
+    let __v_395: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_388; let __vj = __v_389; 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_390; let __vj = __v_391; 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_392; let __vj = __v_393; 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_394; let __vj = __v_395; 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_396: G = G::from_u64(1020);
+    let __v_397: G = (__v_395 - __v_396);
+    let __v_398: G = (__v_394 + __v_397);
+    let __v_399: G = (__v_393 + __v_398);
+    let __v_400: G = (__v_392 + __v_399);
+    let __v_401: G = G::from_bool((__v_400 == G::ZERO));
+    let __v_402: G = (__v_390 + __v_391);
+    let __v_403: G = (__v_389 + __v_402);
+    let __v_404: G = (__v_388 + __v_403);
+    let __v_405: G = G::from_bool((__v_404 == G::ZERO));
+    let __v_406: G = G::from_u64(256);
+    let __v_407: G = (__v_406 * __v_389);
+    let __v_408: G = G::from_u64(65536);
+    let __v_409: G = (__v_408 * __v_390);
+    let __v_410: G = G::from_u64(16777216);
+    let __v_411: G = (__v_410 * __v_391);
+    let __v_412: G = G::from_u64(4294967296);
+    let __v_413: G = (__v_412 * __v_392);
+    let __v_414: G = G::from_u64(1099511627776);
+    let __v_415: G = (__v_414 * __v_393);
+    let __v_416: G = G::from_u64(281474976710656);
+    let __v_417: G = (__v_416 * __v_394);
+    let __v_418: G = G::from_u64(72057594037927936);
+    let __v_419: G = (__v_418 * __v_395);
+    let __v_420: G = (__v_417 + __v_419);
+    let __v_421: G = (__v_415 + __v_420);
+    let __v_422: G = (__v_413 + __v_421);
+    let __v_423: G = (__v_411 + __v_422);
+    let __v_424: G = (__v_409 + __v_423);
+    let __v_425: G = (__v_407 + __v_424);
+    let __v_426: G = (__v_388 + __v_425);
+    if (__v_426 != __v_387) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_426.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: None });
+    }
+    let __v_427: G = G::from_u64(1);
+    let __v_428: G = G::from_u64(1);
+    let __v_429: G = (__v_428 - __v_405);
+    let __v_430: G = (__v_401 * __v_429);
+    let __v_431: G = (__v_427 - __v_430);
+    let __v_432: G = G::from_u64(1);
+    if (__v_431 != __v_432) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_432.as_canonical_u64(), msg: None });
+    }
+    let __v_433: G = G::from_u64(0);
+    let __v_434: G = G::from_u64(0);
+    let __v_435: G = { let __values: [G; 10] = [__v_434, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_436: G = { let __values: [G; 10] = [__v_433, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_435]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_437: G = __r_arr[0];
+    let __v_438: G = G::from_u64(0);
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; 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 { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } 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_439: G = __r_arr[0];
+    let __v_440: G = G::from_u64(1);
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; 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 { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } 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_441: G = __r_arr[0];
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; 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 { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_442: G = __r_arr[0];
+    let __v_443: G = __r_arr[1];
+    let __v_444: G = __r_arr[2];
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; 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 { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_445: G = __r_arr[0];
+    let __v_446: G = __r_arr[1];
+    let __v_447: G = __r_arr[2];
+    let __v_448: G = G::from_u64(2);
+    let __v_449: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_450: G = __io_pair.0;
+    let __v_451: G = __io_pair.1;
+    let __v_452: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; 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_453: G = __r_arr[0];
+    let __v_454: G = G::from_u64(103);
+    let __v_455: G = G::from_u64(230);
+    let __v_456: G = G::from_u64(9);
+    let __v_457: G = G::from_u64(106);
+    let __v_458: G = G::from_u64(133);
+    let __v_459: G = G::from_u64(174);
+    let __v_460: G = G::from_u64(103);
+    let __v_461: G = G::from_u64(187);
+    let __v_462: G = G::from_u64(114);
+    let __v_463: G = G::from_u64(243);
+    let __v_464: G = G::from_u64(110);
+    let __v_465: G = G::from_u64(60);
+    let __v_466: G = G::from_u64(58);
+    let __v_467: G = G::from_u64(245);
+    let __v_468: G = G::from_u64(79);
+    let __v_469: G = G::from_u64(165);
+    let __v_470: G = G::from_u64(127);
+    let __v_471: G = G::from_u64(82);
+    let __v_472: G = G::from_u64(14);
+    let __v_473: G = G::from_u64(81);
+    let __v_474: G = G::from_u64(140);
+    let __v_475: G = G::from_u64(104);
+    let __v_476: G = G::from_u64(5);
+    let __v_477: G = G::from_u64(155);
+    let __v_478: G = G::from_u64(171);
+    let __v_479: G = G::from_u64(217);
+    let __v_480: G = G::from_u64(131);
+    let __v_481: G = G::from_u64(31);
+    let __v_482: G = G::from_u64(25);
+    let __v_483: G = G::from_u64(205);
+    let __v_484: G = G::from_u64(224);
+    let __v_485: G = G::from_u64(91);
+    let __v_486: G = G::from_u64(1);
+    let __v_487: G = G::from_u64(1);
+    let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_489: G = G::from_u64(0);
+    let __v_490: G = G::from_u64(0);
+    let __v_491: G = G::from_u64(0);
+    let __v_492: G = G::from_u64(0);
+    let __v_493: G = G::from_u64(0);
+    let __v_494: G = G::from_u64(0);
+    let __v_495: G = G::from_u64(0);
+    let __v_496: G = G::from_u64(0);
+    let __v_497: G = G::from_u64(0);
+    let __v_498: G = G::from_u64(0);
+    let __v_499: G = { let __values: [G; 8] = [__v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_500: G = { let __values: [G; 32] = [__v_454, __v_455, __v_456, __v_457, __v_458, __v_459, __v_460, __v_461, __v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_478, __v_479, __v_480, __v_481, __v_482, __v_483, __v_484, __v_485]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_501: G = G::from_u64(1);
+    let __v_502: G = G::from_u64(1);
+    let __v_503: G = { let __values: [G; 34] = [__v_501, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_453, __v_488, __v_489, __v_490, __v_499, __v_500, __v_503]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_504: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_505: G = __r_arr[0];
+    let __v_506: G = __r_arr[1];
+    let __v_507: G = __r_arr[2];
+    let __v_508: G = __r_arr[3];
+    let __v_509: G = __r_arr[4];
+    let __v_510: G = __r_arr[5];
+    let __v_511: G = __r_arr[6];
+    let __v_512: G = __r_arr[7];
+    let __v_513: G = __r_arr[8];
+    let __v_514: G = __r_arr[9];
+    let __v_515: G = __r_arr[10];
+    let __v_516: G = __r_arr[11];
+    let __v_517: G = __r_arr[12];
+    let __v_518: G = __r_arr[13];
+    let __v_519: G = __r_arr[14];
+    let __v_520: G = __r_arr[15];
+    let __v_521: G = __r_arr[16];
+    let __v_522: G = __r_arr[17];
+    let __v_523: G = __r_arr[18];
+    let __v_524: G = __r_arr[19];
+    let __v_525: G = __r_arr[20];
+    let __v_526: G = __r_arr[21];
+    let __v_527: G = __r_arr[22];
+    let __v_528: G = __r_arr[23];
+    let __v_529: G = __r_arr[24];
+    let __v_530: G = __r_arr[25];
+    let __v_531: G = __r_arr[26];
+    let __v_532: G = __r_arr[27];
+    let __v_533: G = __r_arr[28];
+    let __v_534: G = __r_arr[29];
+    let __v_535: G = __r_arr[30];
+    let __v_536: G = __r_arr[31];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_453]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_537: G = __r_arr[0];
+    let __v_538: G = __r_arr[1];
+    let __v_539: G = __r_arr[2];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_442]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_540: G = __r_arr[0];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_445]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_541: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_542: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_543: G = __r_arr[0];
+    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_537]; 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 { let __r = record.function_queries[219].replay_at(__i); record.virt += __r; } 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_544: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_545: G = __r_arr[0];
+    let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_540, __v_541, __v_544]; 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 { let __r = record.function_queries[222].replay_at(__i); record.virt += __r; } 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_225] = { let __args: [G; IN_225] = [__v_542, __v_543, __v_544, __v_545]; 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 { let __r = record.function_queries[225].replay_at(__i); record.virt += __r; } 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_546: G = G::from_u64(96);
+    if (__v_19 != __v_546) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_546.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    let __v_547: G = G::from_u64(256);
+    let __v_548: G = (__v_547 * __v_74);
+    let __v_549: G = G::from_u64(65536);
+    let __v_550: G = (__v_549 * __v_75);
+    let __v_551: G = G::from_u64(16777216);
+    let __v_552: G = (__v_551 * __v_76);
+    let __v_553: G = (__v_550 + __v_552);
+    let __v_554: G = (__v_548 + __v_553);
+    let __v_555: G = (__v_73 + __v_554);
+    let __v_556: G = G::from_u64(256);
+    let __v_557: G = (__v_556 * __v_78);
+    let __v_558: G = G::from_u64(65536);
+    let __v_559: G = (__v_558 * __v_79);
+    let __v_560: G = G::from_u64(16777216);
+    let __v_561: G = (__v_560 * __v_80);
+    let __v_562: G = (__v_559 + __v_561);
+    let __v_563: G = (__v_557 + __v_562);
+    let __v_564: G = (__v_77 + __v_563);
+    let __v_565: G = G::from_u64(256);
+    let __v_566: G = (__v_565 * __v_82);
+    let __v_567: G = G::from_u64(65536);
+    let __v_568: G = (__v_567 * __v_83);
+    let __v_569: G = G::from_u64(16777216);
+    let __v_570: G = (__v_569 * __v_84);
+    let __v_571: G = (__v_568 + __v_570);
+    let __v_572: G = (__v_566 + __v_571);
+    let __v_573: G = (__v_81 + __v_572);
+    let __v_574: G = G::from_u64(256);
+    let __v_575: G = (__v_574 * __v_86);
+    let __v_576: G = G::from_u64(65536);
+    let __v_577: G = (__v_576 * __v_87);
+    let __v_578: G = G::from_u64(16777216);
+    let __v_579: G = (__v_578 * __v_88);
+    let __v_580: G = (__v_577 + __v_579);
+    let __v_581: G = (__v_575 + __v_580);
+    let __v_582: G = (__v_85 + __v_581);
+    let __v_583: G = G::from_u64(256);
+    let __v_584: G = (__v_583 * __v_90);
+    let __v_585: G = G::from_u64(65536);
+    let __v_586: G = (__v_585 * __v_91);
+    let __v_587: G = G::from_u64(16777216);
+    let __v_588: G = (__v_587 * __v_92);
+    let __v_589: G = (__v_586 + __v_588);
+    let __v_590: G = (__v_584 + __v_589);
+    let __v_591: G = (__v_89 + __v_590);
+    let __v_592: G = G::from_u64(256);
+    let __v_593: G = (__v_592 * __v_94);
+    let __v_594: G = G::from_u64(65536);
+    let __v_595: G = (__v_594 * __v_95);
+    let __v_596: G = G::from_u64(16777216);
+    let __v_597: G = (__v_596 * __v_96);
+    let __v_598: G = (__v_595 + __v_597);
+    let __v_599: G = (__v_593 + __v_598);
+    let __v_600: G = (__v_93 + __v_599);
+    let __v_601: G = G::from_u64(256);
+    let __v_602: G = (__v_601 * __v_98);
+    let __v_603: G = G::from_u64(65536);
+    let __v_604: G = (__v_603 * __v_99);
+    let __v_605: G = G::from_u64(16777216);
+    let __v_606: G = (__v_605 * __v_100);
+    let __v_607: G = (__v_604 + __v_606);
+    let __v_608: G = (__v_602 + __v_607);
+    let __v_609: G = (__v_97 + __v_608);
+    let __v_610: G = G::from_u64(256);
+    let __v_611: G = (__v_610 * __v_102);
+    let __v_612: G = G::from_u64(65536);
+    let __v_613: G = (__v_612 * __v_103);
+    let __v_614: G = G::from_u64(16777216);
+    let __v_615: G = (__v_614 * __v_104);
+    let __v_616: G = (__v_613 + __v_615);
+    let __v_617: G = (__v_611 + __v_616);
+    let __v_618: G = (__v_101 + __v_617);
+    if (__v_555 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_555.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_187: usize = 1;
-const IN_187: usize = 1;
-const OUT_187: usize = 2;
-fn aiur_fn_187(
-  inp: [G; IN_187],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_187], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_187] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_188: usize = 2;
-const IN_188: usize = 2;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
-        let __v_4: G = __r_arr[0];
-        let __v_5: G = __r_arr[1];
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_1 - __v_6);
-        let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-        let __v_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_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_11, __v_9];
-        if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    if (__v_564 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_564.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
     }
-  })
-}
-
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-    let __v_1: G = __r_arr[0];
-    let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
-    let __v_3: G = __r_arr[0];
-    let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_189] = [__v_3, __v_4];
-    if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    if (__v_573 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_573.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_582 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_582.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_591 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_600 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_600.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_609 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_609.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_618 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("join: allowed blob digest mismatch".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_172.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_619: G = __loaded[0];
+    let __v_620: G = __loaded[1];
+    let __v_621: G = __loaded[2];
+    let __v_622: G = G::from_u64(1);
+    let __v_623: G = G::from_u64(1);
+    if (__v_619 != __v_622) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_619.as_canonical_u64(), rhs: __v_622.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    if (__v_620 != __v_623) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_620.as_canonical_u64(), rhs: __v_623.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    if (__v_621 != __v_623) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_621.as_canonical_u64(), rhs: __v_623.as_canonical_u64(), msg: Some("join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    let __v_624: G = G::from_u64(256);
+    let __v_625: G = (__v_624 * __v_251);
+    let __v_626: G = G::from_u64(65536);
+    let __v_627: G = (__v_626 * __v_252);
+    let __v_628: G = G::from_u64(16777216);
+    let __v_629: G = (__v_628 * __v_253);
+    let __v_630: G = (__v_627 + __v_629);
+    let __v_631: G = (__v_625 + __v_630);
+    let __v_632: G = (__v_250 + __v_631);
+    let __v_633: G = G::from_u64(256);
+    let __v_634: G = (__v_633 * __v_255);
+    let __v_635: G = G::from_u64(65536);
+    let __v_636: G = (__v_635 * __v_256);
+    let __v_637: G = G::from_u64(16777216);
+    let __v_638: G = (__v_637 * __v_257);
+    let __v_639: G = (__v_636 + __v_638);
+    let __v_640: G = (__v_634 + __v_639);
+    let __v_641: G = (__v_254 + __v_640);
+    let __v_642: G = G::from_u64(256);
+    let __v_643: G = (__v_642 * __v_259);
+    let __v_644: G = G::from_u64(65536);
+    let __v_645: G = (__v_644 * __v_260);
+    let __v_646: G = G::from_u64(16777216);
+    let __v_647: G = (__v_646 * __v_261);
+    let __v_648: G = (__v_645 + __v_647);
+    let __v_649: G = (__v_643 + __v_648);
+    let __v_650: G = (__v_258 + __v_649);
+    let __v_651: G = G::from_u64(256);
+    let __v_652: G = (__v_651 * __v_263);
+    let __v_653: G = G::from_u64(65536);
+    let __v_654: G = (__v_653 * __v_264);
+    let __v_655: G = G::from_u64(16777216);
+    let __v_656: G = (__v_655 * __v_265);
+    let __v_657: G = (__v_654 + __v_656);
+    let __v_658: G = (__v_652 + __v_657);
+    let __v_659: G = (__v_262 + __v_658);
+    let __v_660: G = G::from_u64(256);
+    let __v_661: G = (__v_660 * __v_267);
+    let __v_662: G = G::from_u64(65536);
+    let __v_663: G = (__v_662 * __v_268);
+    let __v_664: G = G::from_u64(16777216);
+    let __v_665: G = (__v_664 * __v_269);
+    let __v_666: G = (__v_663 + __v_665);
+    let __v_667: G = (__v_661 + __v_666);
+    let __v_668: G = (__v_266 + __v_667);
+    let __v_669: G = G::from_u64(256);
+    let __v_670: G = (__v_669 * __v_271);
+    let __v_671: G = G::from_u64(65536);
+    let __v_672: G = (__v_671 * __v_272);
+    let __v_673: G = G::from_u64(16777216);
+    let __v_674: G = (__v_673 * __v_273);
+    let __v_675: G = (__v_672 + __v_674);
+    let __v_676: G = (__v_670 + __v_675);
+    let __v_677: G = (__v_270 + __v_676);
+    let __v_678: G = G::from_u64(256);
+    let __v_679: G = (__v_678 * __v_275);
+    let __v_680: G = G::from_u64(65536);
+    let __v_681: G = (__v_680 * __v_276);
+    let __v_682: G = G::from_u64(16777216);
+    let __v_683: G = (__v_682 * __v_277);
+    let __v_684: G = (__v_681 + __v_683);
+    let __v_685: G = (__v_679 + __v_684);
+    let __v_686: G = (__v_274 + __v_685);
+    let __v_687: G = G::from_u64(256);
+    let __v_688: G = (__v_687 * __v_279);
+    let __v_689: G = G::from_u64(65536);
+    let __v_690: G = (__v_689 * __v_280);
+    let __v_691: G = G::from_u64(16777216);
+    let __v_692: G = (__v_691 * __v_281);
+    let __v_693: G = (__v_690 + __v_692);
+    let __v_694: G = (__v_688 + __v_693);
+    let __v_695: G = (__v_278 + __v_694);
+    if (__v_632 != __v_181) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_632.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_641 != __v_182) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_641.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_650 != __v_183) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_650.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_659 != __v_184) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_668 != __v_185) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_668.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_677 != __v_186) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_677.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_686 != __v_187) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_686.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_695 != __v_188) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("join: recursion vk digest mismatch".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_696: G = __loaded[0];
+    let __v_697: G = __loaded[1];
+    let __v_698: G = __loaded[2];
+    let __v_699: G = G::from_u64(1);
+    let __v_700: G = G::from_u64(1);
+    if (__v_696 != __v_699) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_696.as_canonical_u64(), rhs: __v_699.as_canonical_u64(), msg: None });
+    }
+    if (__v_697 != __v_700) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_697.as_canonical_u64(), rhs: __v_700.as_canonical_u64(), msg: None });
+    }
+    if (__v_698 != __v_700) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_698.as_canonical_u64(), rhs: __v_700.as_canonical_u64(), msg: None });
+    }
+    let __v_701: G = G::from_u64(256);
+    let __v_702: G = (__v_701 * __v_506);
+    let __v_703: G = G::from_u64(65536);
+    let __v_704: G = (__v_703 * __v_507);
+    let __v_705: G = G::from_u64(16777216);
+    let __v_706: G = (__v_705 * __v_508);
+    let __v_707: G = (__v_704 + __v_706);
+    let __v_708: G = (__v_702 + __v_707);
+    let __v_709: G = (__v_505 + __v_708);
+    let __v_710: G = G::from_u64(256);
+    let __v_711: G = (__v_710 * __v_510);
+    let __v_712: G = G::from_u64(65536);
+    let __v_713: G = (__v_712 * __v_511);
+    let __v_714: G = G::from_u64(16777216);
+    let __v_715: G = (__v_714 * __v_512);
+    let __v_716: G = (__v_713 + __v_715);
+    let __v_717: G = (__v_711 + __v_716);
+    let __v_718: G = (__v_509 + __v_717);
+    let __v_719: G = G::from_u64(256);
+    let __v_720: G = (__v_719 * __v_514);
+    let __v_721: G = G::from_u64(65536);
+    let __v_722: G = (__v_721 * __v_515);
+    let __v_723: G = G::from_u64(16777216);
+    let __v_724: G = (__v_723 * __v_516);
+    let __v_725: G = (__v_722 + __v_724);
+    let __v_726: G = (__v_720 + __v_725);
+    let __v_727: G = (__v_513 + __v_726);
+    let __v_728: G = G::from_u64(256);
+    let __v_729: G = (__v_728 * __v_518);
+    let __v_730: G = G::from_u64(65536);
+    let __v_731: G = (__v_730 * __v_519);
+    let __v_732: G = G::from_u64(16777216);
+    let __v_733: G = (__v_732 * __v_520);
+    let __v_734: G = (__v_731 + __v_733);
+    let __v_735: G = (__v_729 + __v_734);
+    let __v_736: G = (__v_517 + __v_735);
+    let __v_737: G = G::from_u64(256);
+    let __v_738: G = (__v_737 * __v_522);
+    let __v_739: G = G::from_u64(65536);
+    let __v_740: G = (__v_739 * __v_523);
+    let __v_741: G = G::from_u64(16777216);
+    let __v_742: G = (__v_741 * __v_524);
+    let __v_743: G = (__v_740 + __v_742);
+    let __v_744: G = (__v_738 + __v_743);
+    let __v_745: G = (__v_521 + __v_744);
+    let __v_746: G = G::from_u64(256);
+    let __v_747: G = (__v_746 * __v_526);
+    let __v_748: G = G::from_u64(65536);
+    let __v_749: G = (__v_748 * __v_527);
+    let __v_750: G = G::from_u64(16777216);
+    let __v_751: G = (__v_750 * __v_528);
+    let __v_752: G = (__v_749 + __v_751);
+    let __v_753: G = (__v_747 + __v_752);
+    let __v_754: G = (__v_525 + __v_753);
+    let __v_755: G = G::from_u64(256);
+    let __v_756: G = (__v_755 * __v_530);
+    let __v_757: G = G::from_u64(65536);
+    let __v_758: G = (__v_757 * __v_531);
+    let __v_759: G = G::from_u64(16777216);
+    let __v_760: G = (__v_759 * __v_532);
+    let __v_761: G = (__v_758 + __v_760);
+    let __v_762: G = (__v_756 + __v_761);
+    let __v_763: G = (__v_529 + __v_762);
+    let __v_764: G = G::from_u64(256);
+    let __v_765: G = (__v_764 * __v_534);
+    let __v_766: G = G::from_u64(65536);
+    let __v_767: G = (__v_766 * __v_535);
+    let __v_768: G = G::from_u64(16777216);
+    let __v_769: G = (__v_768 * __v_536);
+    let __v_770: G = (__v_767 + __v_769);
+    let __v_771: G = (__v_765 + __v_770);
+    let __v_772: G = (__v_533 + __v_771);
+    if (__v_709 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_709.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_718 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_718.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_727 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_727.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_736 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_736.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_745 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_745.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_754 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_754.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_763 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_763.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_772 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_772.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("join: output claim digest mismatch".to_string()) });
+    }
+    let __ret: [G; OUT_239] = [];
+    if !unconstrained { record.virt += record.function_queries[239].weight(); } record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_190: usize = 2;
-const IN_190: usize = 2;
-const OUT_190: usize = 2;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_240: usize = 16;
+const IN_240: usize = 16;
+const OUT_240: usize = 0;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(1);
-        let __v_3: G = G::from_u64(1);
-        let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_4, __v_0];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_23(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } } else { aiur_fn_23(__args, record, io_buffer, __cu)? } };
-        let __v_2: G = __r_arr[0];
-        let __v_3: G = __r_arr[1];
-        let __v_4: G = __r_arr[2];
-        let __v_5: G = __r_arr[3];
-        let __v_6: G = __r_arr[4];
-        let __v_7: G = __r_arr[5];
-        let __v_8: G = __r_arr[6];
-        let __v_9: G = __r_arr[7];
-        let __v_10: G = __r_arr[8];
-        let __v_11: G = G::from_u64(1);
-        let __v_12: G = (__v_1 - __v_11);
-        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
-        let __v_15: G = G::from_u64(0);
-        let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_16, __v_14];
-        if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __v_10: G = inp[10];
+    let __v_11: G = inp[11];
+    let __v_12: G = inp[12];
+    let __v_13: G = inp[13];
+    let __v_14: G = inp[14];
+    let __v_15: G = inp[15];
+    let __v_16: G = G::from_u64(3);
+    let __v_17: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_18: G = __io_pair.0;
+    let __v_19: G = __io_pair.1;
+    let __v_20: G = G::from_u64(3);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; 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_21: G = __r_arr[0];
+    let __v_22: G = G::from_u64(103);
+    let __v_23: G = G::from_u64(230);
+    let __v_24: G = G::from_u64(9);
+    let __v_25: G = G::from_u64(106);
+    let __v_26: G = G::from_u64(133);
+    let __v_27: G = G::from_u64(174);
+    let __v_28: G = G::from_u64(103);
+    let __v_29: G = G::from_u64(187);
+    let __v_30: G = G::from_u64(114);
+    let __v_31: G = G::from_u64(243);
+    let __v_32: G = G::from_u64(110);
+    let __v_33: G = G::from_u64(60);
+    let __v_34: G = G::from_u64(58);
+    let __v_35: G = G::from_u64(245);
+    let __v_36: G = G::from_u64(79);
+    let __v_37: G = G::from_u64(165);
+    let __v_38: G = G::from_u64(127);
+    let __v_39: G = G::from_u64(82);
+    let __v_40: G = G::from_u64(14);
+    let __v_41: G = G::from_u64(81);
+    let __v_42: G = G::from_u64(140);
+    let __v_43: G = G::from_u64(104);
+    let __v_44: G = G::from_u64(5);
+    let __v_45: G = G::from_u64(155);
+    let __v_46: G = G::from_u64(171);
+    let __v_47: G = G::from_u64(217);
+    let __v_48: G = G::from_u64(131);
+    let __v_49: G = G::from_u64(31);
+    let __v_50: G = G::from_u64(25);
+    let __v_51: G = G::from_u64(205);
+    let __v_52: G = G::from_u64(224);
+    let __v_53: G = G::from_u64(91);
+    let __v_54: G = G::from_u64(1);
+    let __v_55: G = G::from_u64(1);
+    let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_57: G = G::from_u64(0);
+    let __v_58: G = G::from_u64(0);
+    let __v_59: G = G::from_u64(0);
+    let __v_60: G = G::from_u64(0);
+    let __v_61: G = G::from_u64(0);
+    let __v_62: G = G::from_u64(0);
+    let __v_63: G = G::from_u64(0);
+    let __v_64: G = G::from_u64(0);
+    let __v_65: G = G::from_u64(0);
+    let __v_66: G = G::from_u64(0);
+    let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_69: G = G::from_u64(1);
+    let __v_70: G = G::from_u64(1);
+    let __v_71: G = { let __values: [G; 34] = [__v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_72: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_73: G = __r_arr[0];
+    let __v_74: G = __r_arr[1];
+    let __v_75: G = __r_arr[2];
+    let __v_76: G = __r_arr[3];
+    let __v_77: G = __r_arr[4];
+    let __v_78: G = __r_arr[5];
+    let __v_79: G = __r_arr[6];
+    let __v_80: G = __r_arr[7];
+    let __v_81: G = __r_arr[8];
+    let __v_82: G = __r_arr[9];
+    let __v_83: G = __r_arr[10];
+    let __v_84: G = __r_arr[11];
+    let __v_85: G = __r_arr[12];
+    let __v_86: G = __r_arr[13];
+    let __v_87: G = __r_arr[14];
+    let __v_88: G = __r_arr[15];
+    let __v_89: G = __r_arr[16];
+    let __v_90: G = __r_arr[17];
+    let __v_91: G = __r_arr[18];
+    let __v_92: G = __r_arr[19];
+    let __v_93: G = __r_arr[20];
+    let __v_94: G = __r_arr[21];
+    let __v_95: G = __r_arr[22];
+    let __v_96: G = __r_arr[23];
+    let __v_97: G = __r_arr[24];
+    let __v_98: G = __r_arr[25];
+    let __v_99: G = __r_arr[26];
+    let __v_100: G = __r_arr[27];
+    let __v_101: G = __r_arr[28];
+    let __v_102: G = __r_arr[29];
+    let __v_103: G = __r_arr[30];
+    let __v_104: G = __r_arr[31];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_21]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_105: G = __r_arr[0];
+    let __v_106: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_107: G = __r_arr[0];
+    let __v_108: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_109: G = __r_arr[0];
+    let __v_110: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_111: G = __r_arr[0];
+    let __v_112: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_113: G = __r_arr[0];
+    let __v_114: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_115: G = __r_arr[0];
+    let __v_116: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_117: G = __r_arr[0];
+    let __v_118: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_119: G = __r_arr[0];
+    let __v_120: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_121: G = __r_arr[0];
+    let __v_122: G = __r_arr[1];
+    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_122]; 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 { let __r = record.function_queries[206].replay_at(__i); record.virt += __r; } 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_123: G = __r_arr[0];
+    let __v_124: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_125: G = __r_arr[0];
+    let __v_126: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_129: G = __r_arr[0];
+    let __v_130: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_131: G = __r_arr[0];
+    let __v_132: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_133: G = __r_arr[0];
+    let __v_134: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_135: G = __r_arr[0];
+    let __v_136: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_137: G = __r_arr[0];
+    let __v_138: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_139: G = __r_arr[0];
+    let __v_140: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_141: G = __r_arr[0];
+    let __v_142: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_143: G = __r_arr[0];
+    let __v_144: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_145: G = __r_arr[0];
+    let __v_146: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_147: G = __r_arr[0];
+    let __v_148: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_149: G = __r_arr[0];
+    let __v_150: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_151: G = __r_arr[0];
+    let __v_152: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_153: G = __r_arr[0];
+    let __v_154: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_155: G = __r_arr[0];
+    let __v_156: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_157: G = __r_arr[0];
+    let __v_158: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_161: G = __r_arr[0];
+    let __v_162: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_163: G = __r_arr[0];
+    let __v_164: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_165: G = __r_arr[0];
+    let __v_166: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_167: G = __r_arr[0];
+    let __v_168: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[25].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } };
+    let __v_171: G = __r_arr[0];
+    let __v_172: G = __r_arr[1];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_105]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_173: G = __r_arr[0];
+    let __v_174: G = __r_arr[1];
+    let __v_175: G = __r_arr[2];
+    let __v_176: G = __r_arr[3];
+    let __v_177: G = __r_arr[4];
+    let __v_178: G = __r_arr[5];
+    let __v_179: G = __r_arr[6];
+    let __v_180: G = __r_arr[7];
+    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_123]; 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 { let __r = record.function_queries[208].replay_at(__i); record.virt += __r; } 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_181: G = __r_arr[0];
+    let __v_182: G = __r_arr[1];
+    let __v_183: G = __r_arr[2];
+    let __v_184: G = __r_arr[3];
+    let __v_185: G = __r_arr[4];
+    let __v_186: G = __r_arr[5];
+    let __v_187: G = __r_arr[6];
+    let __v_188: G = __r_arr[7];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_189: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_190: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_191: G = __r_arr[0];
+    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; 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 { let __r = record.function_queries[13].replay_at(__i); record.virt += __r; } 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_192: G = __r_arr[0];
+    let __v_193: G = G::from_u64(1);
+    let __v_194: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_194]; let __info = io_buffer.get_info(__v_193, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_195: G = __io_pair.0;
+    let __v_196: G = __io_pair.1;
+    let __v_197: G = G::from_u64(1);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; 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_198: G = __r_arr[0];
+    let __v_199: G = G::from_u64(103);
+    let __v_200: G = G::from_u64(230);
+    let __v_201: G = G::from_u64(9);
+    let __v_202: G = G::from_u64(106);
+    let __v_203: G = G::from_u64(133);
+    let __v_204: G = G::from_u64(174);
+    let __v_205: G = G::from_u64(103);
+    let __v_206: G = G::from_u64(187);
+    let __v_207: G = G::from_u64(114);
+    let __v_208: G = G::from_u64(243);
+    let __v_209: G = G::from_u64(110);
+    let __v_210: G = G::from_u64(60);
+    let __v_211: G = G::from_u64(58);
+    let __v_212: G = G::from_u64(245);
+    let __v_213: G = G::from_u64(79);
+    let __v_214: G = G::from_u64(165);
+    let __v_215: G = G::from_u64(127);
+    let __v_216: G = G::from_u64(82);
+    let __v_217: G = G::from_u64(14);
+    let __v_218: G = G::from_u64(81);
+    let __v_219: G = G::from_u64(140);
+    let __v_220: G = G::from_u64(104);
+    let __v_221: G = G::from_u64(5);
+    let __v_222: G = G::from_u64(155);
+    let __v_223: G = G::from_u64(171);
+    let __v_224: G = G::from_u64(217);
+    let __v_225: G = G::from_u64(131);
+    let __v_226: G = G::from_u64(31);
+    let __v_227: G = G::from_u64(25);
+    let __v_228: G = G::from_u64(205);
+    let __v_229: G = G::from_u64(224);
+    let __v_230: G = G::from_u64(91);
+    let __v_231: G = G::from_u64(1);
+    let __v_232: G = G::from_u64(1);
+    let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(0);
+    let __v_237: G = G::from_u64(0);
+    let __v_238: G = G::from_u64(0);
+    let __v_239: G = G::from_u64(0);
+    let __v_240: G = G::from_u64(0);
+    let __v_241: G = G::from_u64(0);
+    let __v_242: G = G::from_u64(0);
+    let __v_243: G = G::from_u64(0);
+    let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_245: G = { let __values: [G; 32] = [__v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_246: G = G::from_u64(1);
+    let __v_247: G = G::from_u64(1);
+    let __v_248: G = { let __values: [G; 34] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_198, __v_233, __v_234, __v_235, __v_244, __v_245, __v_248]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_249: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_250: G = __r_arr[0];
+    let __v_251: G = __r_arr[1];
+    let __v_252: G = __r_arr[2];
+    let __v_253: G = __r_arr[3];
+    let __v_254: G = __r_arr[4];
+    let __v_255: G = __r_arr[5];
+    let __v_256: G = __r_arr[6];
+    let __v_257: G = __r_arr[7];
+    let __v_258: G = __r_arr[8];
+    let __v_259: G = __r_arr[9];
+    let __v_260: G = __r_arr[10];
+    let __v_261: G = __r_arr[11];
+    let __v_262: G = __r_arr[12];
+    let __v_263: G = __r_arr[13];
+    let __v_264: G = __r_arr[14];
+    let __v_265: G = __r_arr[15];
+    let __v_266: G = __r_arr[16];
+    let __v_267: G = __r_arr[17];
+    let __v_268: G = __r_arr[18];
+    let __v_269: G = __r_arr[19];
+    let __v_270: G = __r_arr[20];
+    let __v_271: G = __r_arr[21];
+    let __v_272: G = __r_arr[22];
+    let __v_273: G = __r_arr[23];
+    let __v_274: G = __r_arr[24];
+    let __v_275: G = __r_arr[25];
+    let __v_276: G = __r_arr[26];
+    let __v_277: G = __r_arr[27];
+    let __v_278: G = __r_arr[28];
+    let __v_279: G = __r_arr[29];
+    let __v_280: G = __r_arr[30];
+    let __v_281: G = __r_arr[31];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_282: G = __r_arr[0];
+    let __v_283: G = __r_arr[1];
+    let __v_284: G = __r_arr[2];
+    let __v_285: G = __r_arr[3];
+    let __v_286: G = __r_arr[4];
+    let __v_287: G = __r_arr[5];
+    let __v_288: G = __r_arr[6];
+    let __v_289: G = __r_arr[7];
+    let __v_290: G = __r_arr[8];
+    let __v_291: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_292: G = __r_arr[0];
+    let __v_293: G = __r_arr[1];
+    let __v_294: G = __r_arr[2];
+    let __v_295: G = __r_arr[3];
+    let __v_296: G = __r_arr[4];
+    let __v_297: G = __r_arr[5];
+    let __v_298: G = __r_arr[6];
+    let __v_299: G = __r_arr[7];
+    let __v_300: G = __r_arr[8];
+    let __v_301: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_302: G = __r_arr[0];
+    let __v_303: G = __r_arr[1];
+    let __v_304: G = __r_arr[2];
+    let __v_305: G = __r_arr[3];
+    let __v_306: G = __r_arr[4];
+    let __v_307: G = __r_arr[5];
+    let __v_308: G = __r_arr[6];
+    let __v_309: G = __r_arr[7];
+    let __v_310: G = __r_arr[8];
+    let __v_311: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_312: G = __r_arr[0];
+    let __v_313: G = __r_arr[1];
+    let __v_314: G = __r_arr[2];
+    let __v_315: G = __r_arr[3];
+    let __v_316: G = __r_arr[4];
+    let __v_317: G = __r_arr[5];
+    let __v_318: G = __r_arr[6];
+    let __v_319: G = __r_arr[7];
+    let __v_320: G = __r_arr[8];
+    let __v_321: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_322: G = __r_arr[0];
+    let __v_323: G = __r_arr[1];
+    let __v_324: G = __r_arr[2];
+    let __v_325: G = __r_arr[3];
+    let __v_326: G = __r_arr[4];
+    let __v_327: G = __r_arr[5];
+    let __v_328: G = __r_arr[6];
+    let __v_329: G = __r_arr[7];
+    let __v_330: G = __r_arr[8];
+    let __v_331: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_332: G = __r_arr[0];
+    let __v_333: G = __r_arr[1];
+    let __v_334: G = __r_arr[2];
+    let __v_335: G = __r_arr[3];
+    let __v_336: G = __r_arr[4];
+    let __v_337: G = __r_arr[5];
+    let __v_338: G = __r_arr[6];
+    let __v_339: G = __r_arr[7];
+    let __v_340: G = __r_arr[8];
+    let __v_341: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_342: G = __r_arr[0];
+    let __v_343: G = __r_arr[1];
+    let __v_344: G = __r_arr[2];
+    let __v_345: G = __r_arr[3];
+    let __v_346: G = __r_arr[4];
+    let __v_347: G = __r_arr[5];
+    let __v_348: G = __r_arr[6];
+    let __v_349: G = __r_arr[7];
+    let __v_350: G = __r_arr[8];
+    let __v_351: G = __r_arr[9];
+    let __v_352: G = G::from_u64(0);
+    let __v_353: G = G::from_u64(0);
+    let __v_354: G = G::from_u64(0);
+    let __v_355: G = G::from_u64(0);
+    let __v_356: G = G::from_u64(0);
+    let __v_357: G = G::from_u64(0);
+    let __v_358: G = G::from_u64(0);
+    let __v_359: G = G::from_u64(1);
+    let __v_360: G = G::from_u64(1);
+    let __v_361: G = { let __values: [G; 10] = [__v_359, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_362: G = { let __values: [G; 10] = [__v_358, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_361]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_363: G = { let __values: [G; 10] = [__v_357, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_362]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_364: G = { let __values: [G; 10] = [__v_356, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_363]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_365: G = { let __values: [G; 10] = [__v_355, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_320, __v_364]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_366: G = { let __values: [G; 10] = [__v_354, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_365]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_367: G = { let __values: [G; 10] = [__v_353, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_366]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_368: G = { let __values: [G; 10] = [__v_352, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_367]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_369: G = __r_arr[0];
+    let __v_370: G = __r_arr[1];
+    let __v_371: G = __r_arr[2];
+    let __v_372: G = __r_arr[3];
+    let __v_373: G = __r_arr[4];
+    let __v_374: G = __r_arr[5];
+    let __v_375: G = __r_arr[6];
+    let __v_376: G = __r_arr[7];
+    let __v_377: G = __r_arr[8];
+    let __v_378: G = __r_arr[9];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_379: G = __r_arr[0];
+    let __v_380: G = __r_arr[1];
+    let __v_381: G = __r_arr[2];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_382: G = __r_arr[0];
+    let __v_383: G = __r_arr[1];
+    let __v_384: G = __r_arr[2];
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_385: G = __r_arr[0];
+    let __v_386: G = __r_arr[1];
+    let __v_387: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_387.as_canonical_u64().to_le_bytes();
+    let __v_388: G = G::from_u8(__gb[0]);
+    let __v_389: G = G::from_u8(__gb[1]);
+    let __v_390: G = G::from_u8(__gb[2]);
+    let __v_391: G = G::from_u8(__gb[3]);
+    let __v_392: G = G::from_u8(__gb[4]);
+    let __v_393: G = G::from_u8(__gb[5]);
+    let __v_394: G = G::from_u8(__gb[6]);
+    let __v_395: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_388; let __vj = __v_389; 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_390; let __vj = __v_391; 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_392; let __vj = __v_393; 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_394; let __vj = __v_395; 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_396: G = G::from_u64(1020);
+    let __v_397: G = (__v_395 - __v_396);
+    let __v_398: G = (__v_394 + __v_397);
+    let __v_399: G = (__v_393 + __v_398);
+    let __v_400: G = (__v_392 + __v_399);
+    let __v_401: G = G::from_bool((__v_400 == G::ZERO));
+    let __v_402: G = (__v_390 + __v_391);
+    let __v_403: G = (__v_389 + __v_402);
+    let __v_404: G = (__v_388 + __v_403);
+    let __v_405: G = G::from_bool((__v_404 == G::ZERO));
+    let __v_406: G = G::from_u64(256);
+    let __v_407: G = (__v_406 * __v_389);
+    let __v_408: G = G::from_u64(65536);
+    let __v_409: G = (__v_408 * __v_390);
+    let __v_410: G = G::from_u64(16777216);
+    let __v_411: G = (__v_410 * __v_391);
+    let __v_412: G = G::from_u64(4294967296);
+    let __v_413: G = (__v_412 * __v_392);
+    let __v_414: G = G::from_u64(1099511627776);
+    let __v_415: G = (__v_414 * __v_393);
+    let __v_416: G = G::from_u64(281474976710656);
+    let __v_417: G = (__v_416 * __v_394);
+    let __v_418: G = G::from_u64(72057594037927936);
+    let __v_419: G = (__v_418 * __v_395);
+    let __v_420: G = (__v_417 + __v_419);
+    let __v_421: G = (__v_415 + __v_420);
+    let __v_422: G = (__v_413 + __v_421);
+    let __v_423: G = (__v_411 + __v_422);
+    let __v_424: G = (__v_409 + __v_423);
+    let __v_425: G = (__v_407 + __v_424);
+    let __v_426: G = (__v_388 + __v_425);
+    if (__v_426 != __v_387) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_426.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: None });
+    }
+    let __v_427: G = G::from_u64(1);
+    let __v_428: G = G::from_u64(1);
+    let __v_429: G = (__v_428 - __v_405);
+    let __v_430: G = (__v_401 * __v_429);
+    let __v_431: G = (__v_427 - __v_430);
+    let __v_432: G = G::from_u64(1);
+    if (__v_431 != __v_432) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_432.as_canonical_u64(), msg: None });
+    }
+    let __v_433: G = G::from_u64(0);
+    let __v_434: G = G::from_u64(0);
+    let __v_435: G = { let __values: [G; 10] = [__v_434, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_436: G = { let __values: [G; 10] = [__v_433, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_435]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_368, __v_436]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_437: G = __r_arr[0];
+    let __v_438: G = G::from_u64(0);
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_438]; 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 { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } 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_439: G = __r_arr[0];
+    let __v_440: G = G::from_u64(1);
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_437, __v_379, __v_382, __v_383, __v_385, __v_440]; 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 { let __r = record.function_queries[236].replay_at(__i); record.virt += __r; } 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_441: G = __r_arr[0];
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_439, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; 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 { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_442: G = __r_arr[0];
+    let __v_443: G = __r_arr[1];
+    let __v_444: G = __r_arr[2];
+    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_441, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; 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 { let __r = record.function_queries[238].replay_at(__i); record.virt += __r; } 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_445: G = __r_arr[0];
+    let __v_446: G = __r_arr[1];
+    let __v_447: G = __r_arr[2];
+    let __v_448: G = G::from_u64(2);
+    let __v_449: G = G::from_u64(2);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_449]; let __info = io_buffer.get_info(__v_448, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_450: G = __io_pair.0;
+    let __v_451: G = __io_pair.1;
+    let __v_452: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_452, __v_450, __v_451]; 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_453: G = __r_arr[0];
+    let __v_454: G = G::from_u64(103);
+    let __v_455: G = G::from_u64(230);
+    let __v_456: G = G::from_u64(9);
+    let __v_457: G = G::from_u64(106);
+    let __v_458: G = G::from_u64(133);
+    let __v_459: G = G::from_u64(174);
+    let __v_460: G = G::from_u64(103);
+    let __v_461: G = G::from_u64(187);
+    let __v_462: G = G::from_u64(114);
+    let __v_463: G = G::from_u64(243);
+    let __v_464: G = G::from_u64(110);
+    let __v_465: G = G::from_u64(60);
+    let __v_466: G = G::from_u64(58);
+    let __v_467: G = G::from_u64(245);
+    let __v_468: G = G::from_u64(79);
+    let __v_469: G = G::from_u64(165);
+    let __v_470: G = G::from_u64(127);
+    let __v_471: G = G::from_u64(82);
+    let __v_472: G = G::from_u64(14);
+    let __v_473: G = G::from_u64(81);
+    let __v_474: G = G::from_u64(140);
+    let __v_475: G = G::from_u64(104);
+    let __v_476: G = G::from_u64(5);
+    let __v_477: G = G::from_u64(155);
+    let __v_478: G = G::from_u64(171);
+    let __v_479: G = G::from_u64(217);
+    let __v_480: G = G::from_u64(131);
+    let __v_481: G = G::from_u64(31);
+    let __v_482: G = G::from_u64(25);
+    let __v_483: G = G::from_u64(205);
+    let __v_484: G = G::from_u64(224);
+    let __v_485: G = G::from_u64(91);
+    let __v_486: G = G::from_u64(1);
+    let __v_487: G = G::from_u64(1);
+    let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_489: G = G::from_u64(0);
+    let __v_490: G = G::from_u64(0);
+    let __v_491: G = G::from_u64(0);
+    let __v_492: G = G::from_u64(0);
+    let __v_493: G = G::from_u64(0);
+    let __v_494: G = G::from_u64(0);
+    let __v_495: G = G::from_u64(0);
+    let __v_496: G = G::from_u64(0);
+    let __v_497: G = G::from_u64(0);
+    let __v_498: G = G::from_u64(0);
+    let __v_499: G = { let __values: [G; 8] = [__v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_500: G = { let __values: [G; 32] = [__v_454, __v_455, __v_456, __v_457, __v_458, __v_459, __v_460, __v_461, __v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_478, __v_479, __v_480, __v_481, __v_482, __v_483, __v_484, __v_485]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_501: G = G::from_u64(1);
+    let __v_502: G = G::from_u64(1);
+    let __v_503: G = { let __values: [G; 34] = [__v_501, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502, __v_502]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_453, __v_488, __v_489, __v_490, __v_499, __v_500, __v_503]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_504: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_504]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_505: G = __r_arr[0];
+    let __v_506: G = __r_arr[1];
+    let __v_507: G = __r_arr[2];
+    let __v_508: G = __r_arr[3];
+    let __v_509: G = __r_arr[4];
+    let __v_510: G = __r_arr[5];
+    let __v_511: G = __r_arr[6];
+    let __v_512: G = __r_arr[7];
+    let __v_513: G = __r_arr[8];
+    let __v_514: G = __r_arr[9];
+    let __v_515: G = __r_arr[10];
+    let __v_516: G = __r_arr[11];
+    let __v_517: G = __r_arr[12];
+    let __v_518: G = __r_arr[13];
+    let __v_519: G = __r_arr[14];
+    let __v_520: G = __r_arr[15];
+    let __v_521: G = __r_arr[16];
+    let __v_522: G = __r_arr[17];
+    let __v_523: G = __r_arr[18];
+    let __v_524: G = __r_arr[19];
+    let __v_525: G = __r_arr[20];
+    let __v_526: G = __r_arr[21];
+    let __v_527: G = __r_arr[22];
+    let __v_528: G = __r_arr[23];
+    let __v_529: G = __r_arr[24];
+    let __v_530: G = __r_arr[25];
+    let __v_531: G = __r_arr[26];
+    let __v_532: G = __r_arr[27];
+    let __v_533: G = __r_arr[28];
+    let __v_534: G = __r_arr[29];
+    let __v_535: G = __r_arr[30];
+    let __v_536: G = __r_arr[31];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_453]; 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 { let __r = record.function_queries[230].replay_at(__i); record.virt += __r; } 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_537: G = __r_arr[0];
+    let __v_538: G = __r_arr[1];
+    let __v_539: G = __r_arr[2];
+    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_442, __v_445]; 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 { let __r = record.function_queries[209].replay_at(__i); record.virt += __r; } 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_540: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_443, __v_444]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_541: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_446, __v_447]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_542: G = __r_arr[0];
+    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_538, __v_539]; 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 { let __r = record.function_queries[220].replay_at(__i); record.virt += __r; } 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_543: G = __r_arr[0];
+    let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_541, __v_542, __v_537, __v_543]; 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 { let __r = record.function_queries[228].replay_at(__i); record.virt += __r; } 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_544: G = G::from_u64(96);
+    if (__v_19 != __v_544) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_544.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    let __v_545: G = G::from_u64(256);
+    let __v_546: G = (__v_545 * __v_74);
+    let __v_547: G = G::from_u64(65536);
+    let __v_548: G = (__v_547 * __v_75);
+    let __v_549: G = G::from_u64(16777216);
+    let __v_550: G = (__v_549 * __v_76);
+    let __v_551: G = (__v_548 + __v_550);
+    let __v_552: G = (__v_546 + __v_551);
+    let __v_553: G = (__v_73 + __v_552);
+    let __v_554: G = G::from_u64(256);
+    let __v_555: G = (__v_554 * __v_78);
+    let __v_556: G = G::from_u64(65536);
+    let __v_557: G = (__v_556 * __v_79);
+    let __v_558: G = G::from_u64(16777216);
+    let __v_559: G = (__v_558 * __v_80);
+    let __v_560: G = (__v_557 + __v_559);
+    let __v_561: G = (__v_555 + __v_560);
+    let __v_562: G = (__v_77 + __v_561);
+    let __v_563: G = G::from_u64(256);
+    let __v_564: G = (__v_563 * __v_82);
+    let __v_565: G = G::from_u64(65536);
+    let __v_566: G = (__v_565 * __v_83);
+    let __v_567: G = G::from_u64(16777216);
+    let __v_568: G = (__v_567 * __v_84);
+    let __v_569: G = (__v_566 + __v_568);
+    let __v_570: G = (__v_564 + __v_569);
+    let __v_571: G = (__v_81 + __v_570);
+    let __v_572: G = G::from_u64(256);
+    let __v_573: G = (__v_572 * __v_86);
+    let __v_574: G = G::from_u64(65536);
+    let __v_575: G = (__v_574 * __v_87);
+    let __v_576: G = G::from_u64(16777216);
+    let __v_577: G = (__v_576 * __v_88);
+    let __v_578: G = (__v_575 + __v_577);
+    let __v_579: G = (__v_573 + __v_578);
+    let __v_580: G = (__v_85 + __v_579);
+    let __v_581: G = G::from_u64(256);
+    let __v_582: G = (__v_581 * __v_90);
+    let __v_583: G = G::from_u64(65536);
+    let __v_584: G = (__v_583 * __v_91);
+    let __v_585: G = G::from_u64(16777216);
+    let __v_586: G = (__v_585 * __v_92);
+    let __v_587: G = (__v_584 + __v_586);
+    let __v_588: G = (__v_582 + __v_587);
+    let __v_589: G = (__v_89 + __v_588);
+    let __v_590: G = G::from_u64(256);
+    let __v_591: G = (__v_590 * __v_94);
+    let __v_592: G = G::from_u64(65536);
+    let __v_593: G = (__v_592 * __v_95);
+    let __v_594: G = G::from_u64(16777216);
+    let __v_595: G = (__v_594 * __v_96);
+    let __v_596: G = (__v_593 + __v_595);
+    let __v_597: G = (__v_591 + __v_596);
+    let __v_598: G = (__v_93 + __v_597);
+    let __v_599: G = G::from_u64(256);
+    let __v_600: G = (__v_599 * __v_98);
+    let __v_601: G = G::from_u64(65536);
+    let __v_602: G = (__v_601 * __v_99);
+    let __v_603: G = G::from_u64(16777216);
+    let __v_604: G = (__v_603 * __v_100);
+    let __v_605: G = (__v_602 + __v_604);
+    let __v_606: G = (__v_600 + __v_605);
+    let __v_607: G = (__v_97 + __v_606);
+    let __v_608: G = G::from_u64(256);
+    let __v_609: G = (__v_608 * __v_102);
+    let __v_610: G = G::from_u64(65536);
+    let __v_611: G = (__v_610 * __v_103);
+    let __v_612: G = G::from_u64(16777216);
+    let __v_613: G = (__v_612 * __v_104);
+    let __v_614: G = (__v_611 + __v_613);
+    let __v_615: G = (__v_609 + __v_614);
+    let __v_616: G = (__v_101 + __v_615);
+    if (__v_553 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_553.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_562 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_562.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_571 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_571.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_580 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_589 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_589.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_598 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_598.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_607 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_607.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    if (__v_616 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_616.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("structural join: allowed blob digest mismatch".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_172.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_617: G = __loaded[0];
+    let __v_618: G = __loaded[1];
+    let __v_619: G = __loaded[2];
+    let __v_620: G = G::from_u64(1);
+    let __v_621: G = G::from_u64(1);
+    if (__v_617 != __v_620) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_617.as_canonical_u64(), rhs: __v_620.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    if (__v_618 != __v_621) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_618.as_canonical_u64(), rhs: __v_621.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    if (__v_619 != __v_621) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_619.as_canonical_u64(), rhs: __v_621.as_canonical_u64(), msg: Some("structural join: allowed blob must be exactly 96 bytes".to_string()) });
+    }
+    let __v_622: G = G::from_u64(256);
+    let __v_623: G = (__v_622 * __v_251);
+    let __v_624: G = G::from_u64(65536);
+    let __v_625: G = (__v_624 * __v_252);
+    let __v_626: G = G::from_u64(16777216);
+    let __v_627: G = (__v_626 * __v_253);
+    let __v_628: G = (__v_625 + __v_627);
+    let __v_629: G = (__v_623 + __v_628);
+    let __v_630: G = (__v_250 + __v_629);
+    let __v_631: G = G::from_u64(256);
+    let __v_632: G = (__v_631 * __v_255);
+    let __v_633: G = G::from_u64(65536);
+    let __v_634: G = (__v_633 * __v_256);
+    let __v_635: G = G::from_u64(16777216);
+    let __v_636: G = (__v_635 * __v_257);
+    let __v_637: G = (__v_634 + __v_636);
+    let __v_638: G = (__v_632 + __v_637);
+    let __v_639: G = (__v_254 + __v_638);
+    let __v_640: G = G::from_u64(256);
+    let __v_641: G = (__v_640 * __v_259);
+    let __v_642: G = G::from_u64(65536);
+    let __v_643: G = (__v_642 * __v_260);
+    let __v_644: G = G::from_u64(16777216);
+    let __v_645: G = (__v_644 * __v_261);
+    let __v_646: G = (__v_643 + __v_645);
+    let __v_647: G = (__v_641 + __v_646);
+    let __v_648: G = (__v_258 + __v_647);
+    let __v_649: G = G::from_u64(256);
+    let __v_650: G = (__v_649 * __v_263);
+    let __v_651: G = G::from_u64(65536);
+    let __v_652: G = (__v_651 * __v_264);
+    let __v_653: G = G::from_u64(16777216);
+    let __v_654: G = (__v_653 * __v_265);
+    let __v_655: G = (__v_652 + __v_654);
+    let __v_656: G = (__v_650 + __v_655);
+    let __v_657: G = (__v_262 + __v_656);
+    let __v_658: G = G::from_u64(256);
+    let __v_659: G = (__v_658 * __v_267);
+    let __v_660: G = G::from_u64(65536);
+    let __v_661: G = (__v_660 * __v_268);
+    let __v_662: G = G::from_u64(16777216);
+    let __v_663: G = (__v_662 * __v_269);
+    let __v_664: G = (__v_661 + __v_663);
+    let __v_665: G = (__v_659 + __v_664);
+    let __v_666: G = (__v_266 + __v_665);
+    let __v_667: G = G::from_u64(256);
+    let __v_668: G = (__v_667 * __v_271);
+    let __v_669: G = G::from_u64(65536);
+    let __v_670: G = (__v_669 * __v_272);
+    let __v_671: G = G::from_u64(16777216);
+    let __v_672: G = (__v_671 * __v_273);
+    let __v_673: G = (__v_670 + __v_672);
+    let __v_674: G = (__v_668 + __v_673);
+    let __v_675: G = (__v_270 + __v_674);
+    let __v_676: G = G::from_u64(256);
+    let __v_677: G = (__v_676 * __v_275);
+    let __v_678: G = G::from_u64(65536);
+    let __v_679: G = (__v_678 * __v_276);
+    let __v_680: G = G::from_u64(16777216);
+    let __v_681: G = (__v_680 * __v_277);
+    let __v_682: G = (__v_679 + __v_681);
+    let __v_683: G = (__v_677 + __v_682);
+    let __v_684: G = (__v_274 + __v_683);
+    let __v_685: G = G::from_u64(256);
+    let __v_686: G = (__v_685 * __v_279);
+    let __v_687: G = G::from_u64(65536);
+    let __v_688: G = (__v_687 * __v_280);
+    let __v_689: G = G::from_u64(16777216);
+    let __v_690: G = (__v_689 * __v_281);
+    let __v_691: G = (__v_688 + __v_690);
+    let __v_692: G = (__v_686 + __v_691);
+    let __v_693: G = (__v_278 + __v_692);
+    if (__v_630 != __v_181) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_630.as_canonical_u64(), rhs: __v_181.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_639 != __v_182) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_639.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_648 != __v_183) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
     }
+    if (__v_657 != __v_184) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_657.as_canonical_u64(), rhs: __v_184.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_666 != __v_185) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_666.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_675 != __v_186) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_675.as_canonical_u64(), rhs: __v_186.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_684 != __v_187) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_684.as_canonical_u64(), rhs: __v_187.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    if (__v_693 != __v_188) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_693.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("structural join: recursion vk digest mismatch".to_string()) });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_694: G = __loaded[0];
+    let __v_695: G = __loaded[1];
+    let __v_696: G = __loaded[2];
+    let __v_697: G = G::from_u64(1);
+    let __v_698: G = G::from_u64(1);
+    if (__v_694 != __v_697) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_694.as_canonical_u64(), rhs: __v_697.as_canonical_u64(), msg: None });
+    }
+    if (__v_695 != __v_698) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_695.as_canonical_u64(), rhs: __v_698.as_canonical_u64(), msg: None });
+    }
+    if (__v_696 != __v_698) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_696.as_canonical_u64(), rhs: __v_698.as_canonical_u64(), msg: None });
+    }
+    let __v_699: G = G::from_u64(256);
+    let __v_700: G = (__v_699 * __v_506);
+    let __v_701: G = G::from_u64(65536);
+    let __v_702: G = (__v_701 * __v_507);
+    let __v_703: G = G::from_u64(16777216);
+    let __v_704: G = (__v_703 * __v_508);
+    let __v_705: G = (__v_702 + __v_704);
+    let __v_706: G = (__v_700 + __v_705);
+    let __v_707: G = (__v_505 + __v_706);
+    let __v_708: G = G::from_u64(256);
+    let __v_709: G = (__v_708 * __v_510);
+    let __v_710: G = G::from_u64(65536);
+    let __v_711: G = (__v_710 * __v_511);
+    let __v_712: G = G::from_u64(16777216);
+    let __v_713: G = (__v_712 * __v_512);
+    let __v_714: G = (__v_711 + __v_713);
+    let __v_715: G = (__v_709 + __v_714);
+    let __v_716: G = (__v_509 + __v_715);
+    let __v_717: G = G::from_u64(256);
+    let __v_718: G = (__v_717 * __v_514);
+    let __v_719: G = G::from_u64(65536);
+    let __v_720: G = (__v_719 * __v_515);
+    let __v_721: G = G::from_u64(16777216);
+    let __v_722: G = (__v_721 * __v_516);
+    let __v_723: G = (__v_720 + __v_722);
+    let __v_724: G = (__v_718 + __v_723);
+    let __v_725: G = (__v_513 + __v_724);
+    let __v_726: G = G::from_u64(256);
+    let __v_727: G = (__v_726 * __v_518);
+    let __v_728: G = G::from_u64(65536);
+    let __v_729: G = (__v_728 * __v_519);
+    let __v_730: G = G::from_u64(16777216);
+    let __v_731: G = (__v_730 * __v_520);
+    let __v_732: G = (__v_729 + __v_731);
+    let __v_733: G = (__v_727 + __v_732);
+    let __v_734: G = (__v_517 + __v_733);
+    let __v_735: G = G::from_u64(256);
+    let __v_736: G = (__v_735 * __v_522);
+    let __v_737: G = G::from_u64(65536);
+    let __v_738: G = (__v_737 * __v_523);
+    let __v_739: G = G::from_u64(16777216);
+    let __v_740: G = (__v_739 * __v_524);
+    let __v_741: G = (__v_738 + __v_740);
+    let __v_742: G = (__v_736 + __v_741);
+    let __v_743: G = (__v_521 + __v_742);
+    let __v_744: G = G::from_u64(256);
+    let __v_745: G = (__v_744 * __v_526);
+    let __v_746: G = G::from_u64(65536);
+    let __v_747: G = (__v_746 * __v_527);
+    let __v_748: G = G::from_u64(16777216);
+    let __v_749: G = (__v_748 * __v_528);
+    let __v_750: G = (__v_747 + __v_749);
+    let __v_751: G = (__v_745 + __v_750);
+    let __v_752: G = (__v_525 + __v_751);
+    let __v_753: G = G::from_u64(256);
+    let __v_754: G = (__v_753 * __v_530);
+    let __v_755: G = G::from_u64(65536);
+    let __v_756: G = (__v_755 * __v_531);
+    let __v_757: G = G::from_u64(16777216);
+    let __v_758: G = (__v_757 * __v_532);
+    let __v_759: G = (__v_756 + __v_758);
+    let __v_760: G = (__v_754 + __v_759);
+    let __v_761: G = (__v_529 + __v_760);
+    let __v_762: G = G::from_u64(256);
+    let __v_763: G = (__v_762 * __v_534);
+    let __v_764: G = G::from_u64(65536);
+    let __v_765: G = (__v_764 * __v_535);
+    let __v_766: G = G::from_u64(16777216);
+    let __v_767: G = (__v_766 * __v_536);
+    let __v_768: G = (__v_765 + __v_767);
+    let __v_769: G = (__v_763 + __v_768);
+    let __v_770: G = (__v_533 + __v_769);
+    if (__v_707 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_707.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_716 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_716.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_725 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_725.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_734 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_734.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_743 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_743.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_752 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_752.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_761 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_761.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    if (__v_770 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_770.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) });
+    }
+    let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_537, __v_540]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[2].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
+    let __v_771: G = __r_arr[0];
+    let __v_772: G = G::from_u64(1);
+    if (__v_771 != __v_772) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_771.as_canonical_u64(), rhs: __v_772.as_canonical_u64(), msg: Some("structural join: output subject root is not nodeHash(left, right)".to_string()) });
+    }
+    let __ret: [G; OUT_240] = [];
+    if !unconstrained { record.virt += record.function_queries[240].weight(); } record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+    return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_191: usize = 16;
-const IN_191: usize = 16;
-const OUT_191: usize = 0;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_241: usize = 16;
+const IN_241: usize = 16;
+const OUT_241: usize = 0;
+fn aiur_fn_241(
+  inp: [G; IN_241],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_241], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
@@ -18218,961 +25562,1061 @@ fn aiur_fn_191(
     let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
     let __v_18: G = __io_pair.0;
     let __v_19: G = __io_pair.1;
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_21, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_21, __v_20]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_22: G = __r_arr[0];
     let __v_23: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
-    let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[36].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_36(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_36] = unsafe { *(result.output.as_ptr() as *const [G; OUT_36]) }; __ret } } else { aiur_fn_36(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[39].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_29]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
     let __v_33: G = __r_arr[1];
-    let __r_arr: [G; OUT_31] = { let __args: [G; IN_31] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[31].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_31(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_31] = unsafe { *(result.output.as_ptr() as *const [G; OUT_31]) }; __ret } } else { aiur_fn_31(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_33, __v_32]; 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 { let __r = record.function_queries[34].replay_at(__i); record.virt += __r; } 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_34: G = __r_arr[0];
     let __v_35: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_36: G = __r_arr[0];
     let __v_37: G = __r_arr[1];
-    let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_46(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_46] = unsafe { *(result.output.as_ptr() as *const [G; OUT_46]) }; __ret } } else { aiur_fn_46(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_37, __v_36]; 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 { let __r = record.function_queries[51].replay_at(__i); record.virt += __r; } 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_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_32(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_32] = unsafe { *(result.output.as_ptr() as *const [G; OUT_32]) }; __ret } } else { aiur_fn_32(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[35].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } };
     let __v_40: G = __r_arr[0];
     let __v_41: G = __r_arr[1];
-    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_27(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_27] = unsafe { *(result.output.as_ptr() as *const [G; OUT_27]) }; __ret } } else { aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_42: G = __r_arr[0];
     let __v_43: G = __r_arr[1];
-    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_43, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[56].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_56(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_56] = unsafe { *(result.output.as_ptr() as *const [G; OUT_56]) }; __ret } } else { aiur_fn_56(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_42]; 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 { let __r = record.function_queries[55].replay_at(__i); record.virt += __r; } 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_44: G = __r_arr[0];
     let __v_45: G = __r_arr[1];
-    let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_34(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_34] = unsafe { *(result.output.as_ptr() as *const [G; OUT_34]) }; __ret } } else { aiur_fn_34(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[30].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } };
     let __v_46: G = __r_arr[0];
     let __v_47: G = __r_arr[1];
-    let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_47]; let __cu = true; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_26(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } } else { aiur_fn_26(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_47, __v_46]; 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 { let __r = record.function_queries[58].replay_at(__i); record.virt += __r; } 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_48: G = __r_arr[0];
     let __v_49: G = __r_arr[1];
-    let __v_50: G = __r_arr[2];
-    let __v_51: G = __r_arr[3];
-    let __v_52: G = __r_arr[4];
-    let __v_53: G = __r_arr[5];
-    let __v_54: G = __r_arr[6];
-    let __v_55: G = __r_arr[7];
-    let __v_56: G = __r_arr[8];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_57: G = __r_arr[0];
-    let __v_58: G = __r_arr[1];
-    let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_58(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } } else { aiur_fn_58(__args, record, io_buffer, __cu)? } };
-    let __v_59: G = __r_arr[0];
-    let __v_60: G = __r_arr[1];
-    let __v_61: G = __r_arr[2];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_62: G = __r_arr[0];
-    let __v_63: G = __r_arr[1];
-    let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_42(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_42] = unsafe { *(result.output.as_ptr() as *const [G; OUT_42]) }; __ret } } else { aiur_fn_42(__args, record, io_buffer, __cu)? } };
-    let __v_64: G = __r_arr[0];
-    let __v_65: G = __r_arr[1];
-    let __v_66: G = G::from_u64(1);
-    let __v_67: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_67]; let __info = io_buffer.get_info(__v_66, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_68: G = __io_pair.0;
-    let __v_69: G = __io_pair.1;
+    let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_49]; 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 { let __r = record.function_queries[37].replay_at(__i); record.virt += __r; } 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_50: G = __r_arr[0];
+    let __v_51: G = __r_arr[1];
+    let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_51]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } };
+    let __v_52: G = __r_arr[0];
+    let __v_53: G = __r_arr[1];
+    let __v_54: G = __r_arr[2];
+    let __v_55: G = __r_arr[3];
+    let __v_56: G = __r_arr[4];
+    let __v_57: G = __r_arr[5];
+    let __v_58: G = __r_arr[6];
+    let __v_59: G = __r_arr[7];
+    let __v_60: G = __r_arr[8];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_60]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_62]; 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 { let __r = record.function_queries[60].replay_at(__i); record.virt += __r; } 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_63: G = __r_arr[0];
+    let __v_64: G = __r_arr[1];
+    let __v_65: G = __r_arr[2];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_65]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_66: G = __r_arr[0];
+    let __v_67: G = __r_arr[1];
+    let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_67]; 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 { let __r = record.function_queries[47].replay_at(__i); record.virt += __r; } 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_68: G = __r_arr[0];
+    let __v_69: G = __r_arr[1];
     let __v_70: G = G::from_u64(1);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_70, __v_68, __v_69]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_71: G = __r_arr[0];
-    let __v_72: G = G::from_u64(103);
-    let __v_73: G = G::from_u64(230);
-    let __v_74: G = G::from_u64(9);
-    let __v_75: G = G::from_u64(106);
-    let __v_76: G = G::from_u64(133);
-    let __v_77: G = G::from_u64(174);
-    let __v_78: G = G::from_u64(103);
-    let __v_79: G = G::from_u64(187);
-    let __v_80: G = G::from_u64(114);
-    let __v_81: G = G::from_u64(243);
-    let __v_82: G = G::from_u64(110);
-    let __v_83: G = G::from_u64(60);
-    let __v_84: G = G::from_u64(58);
-    let __v_85: G = G::from_u64(245);
-    let __v_86: G = G::from_u64(79);
-    let __v_87: G = G::from_u64(165);
-    let __v_88: G = G::from_u64(127);
-    let __v_89: G = G::from_u64(82);
-    let __v_90: G = G::from_u64(14);
-    let __v_91: G = G::from_u64(81);
-    let __v_92: G = G::from_u64(140);
-    let __v_93: G = G::from_u64(104);
-    let __v_94: G = G::from_u64(5);
-    let __v_95: G = G::from_u64(155);
-    let __v_96: G = G::from_u64(171);
-    let __v_97: G = G::from_u64(217);
-    let __v_98: G = G::from_u64(131);
-    let __v_99: G = G::from_u64(31);
-    let __v_100: G = G::from_u64(25);
-    let __v_101: G = G::from_u64(205);
-    let __v_102: G = G::from_u64(224);
-    let __v_103: G = G::from_u64(91);
-    let __v_104: G = G::from_u64(1);
-    let __v_105: G = G::from_u64(1);
-    let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_107: G = G::from_u64(0);
-    let __v_108: G = G::from_u64(0);
-    let __v_109: G = G::from_u64(0);
-    let __v_110: G = G::from_u64(0);
+    let __v_71: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_71]; let __info = io_buffer.get_info(__v_70, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_72: G = __io_pair.0;
+    let __v_73: G = __io_pair.1;
+    let __v_74: G = G::from_u64(1);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_74, __v_72, __v_73]; 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_75: G = __r_arr[0];
+    let __v_76: G = G::from_u64(103);
+    let __v_77: G = G::from_u64(230);
+    let __v_78: G = G::from_u64(9);
+    let __v_79: G = G::from_u64(106);
+    let __v_80: G = G::from_u64(133);
+    let __v_81: G = G::from_u64(174);
+    let __v_82: G = G::from_u64(103);
+    let __v_83: G = G::from_u64(187);
+    let __v_84: G = G::from_u64(114);
+    let __v_85: G = G::from_u64(243);
+    let __v_86: G = G::from_u64(110);
+    let __v_87: G = G::from_u64(60);
+    let __v_88: G = G::from_u64(58);
+    let __v_89: G = G::from_u64(245);
+    let __v_90: G = G::from_u64(79);
+    let __v_91: G = G::from_u64(165);
+    let __v_92: G = G::from_u64(127);
+    let __v_93: G = G::from_u64(82);
+    let __v_94: G = G::from_u64(14);
+    let __v_95: G = G::from_u64(81);
+    let __v_96: G = G::from_u64(140);
+    let __v_97: G = G::from_u64(104);
+    let __v_98: G = G::from_u64(5);
+    let __v_99: G = G::from_u64(155);
+    let __v_100: G = G::from_u64(171);
+    let __v_101: G = G::from_u64(217);
+    let __v_102: G = G::from_u64(131);
+    let __v_103: G = G::from_u64(31);
+    let __v_104: G = G::from_u64(25);
+    let __v_105: G = G::from_u64(205);
+    let __v_106: G = G::from_u64(224);
+    let __v_107: G = G::from_u64(91);
+    let __v_108: G = G::from_u64(1);
+    let __v_109: G = G::from_u64(1);
+    let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
     let __v_111: G = G::from_u64(0);
     let __v_112: G = G::from_u64(0);
     let __v_113: G = G::from_u64(0);
     let __v_114: G = G::from_u64(0);
     let __v_115: G = G::from_u64(0);
     let __v_116: G = G::from_u64(0);
-    let __v_117: G = { let __values: [G; 8] = [__v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_118: G = { let __values: [G; 32] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_119: G = G::from_u64(1);
-    let __v_120: G = G::from_u64(1);
-    let __v_121: G = { let __values: [G; 34] = [__v_119, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120, __v_120]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_71, __v_106, __v_107, __v_108, __v_117, __v_118, __v_121]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-    let __v_122: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_122]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
-    let __v_123: G = __r_arr[0];
-    let __v_124: G = __r_arr[1];
-    let __v_125: G = __r_arr[2];
-    let __v_126: G = __r_arr[3];
-    let __v_127: G = __r_arr[4];
-    let __v_128: G = __r_arr[5];
-    let __v_129: G = __r_arr[6];
-    let __v_130: G = __r_arr[7];
-    let __v_131: G = __r_arr[8];
-    let __v_132: G = __r_arr[9];
-    let __v_133: G = __r_arr[10];
-    let __v_134: G = __r_arr[11];
-    let __v_135: G = __r_arr[12];
-    let __v_136: G = __r_arr[13];
-    let __v_137: G = __r_arr[14];
-    let __v_138: G = __r_arr[15];
-    let __v_139: G = __r_arr[16];
-    let __v_140: G = __r_arr[17];
-    let __v_141: G = __r_arr[18];
-    let __v_142: G = __r_arr[19];
-    let __v_143: G = __r_arr[20];
-    let __v_144: G = __r_arr[21];
-    let __v_145: G = __r_arr[22];
-    let __v_146: G = __r_arr[23];
-    let __v_147: G = __r_arr[24];
-    let __v_148: G = __r_arr[25];
-    let __v_149: G = __r_arr[26];
-    let __v_150: G = __r_arr[27];
-    let __v_151: G = __r_arr[28];
-    let __v_152: G = __r_arr[29];
-    let __v_153: G = __r_arr[30];
-    let __v_154: G = __r_arr[31];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_155: G = __r_arr[0];
-    let __v_156: G = __r_arr[1];
-    let __v_157: G = __r_arr[2];
-    let __v_158: G = __r_arr[3];
-    let __v_159: G = __r_arr[4];
-    let __v_160: G = __r_arr[5];
-    let __v_161: G = __r_arr[6];
-    let __v_162: G = __r_arr[7];
-    let __v_163: G = __r_arr[8];
-    let __v_164: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_165: G = __r_arr[0];
-    let __v_166: G = __r_arr[1];
-    let __v_167: G = __r_arr[2];
-    let __v_168: G = __r_arr[3];
-    let __v_169: G = __r_arr[4];
-    let __v_170: G = __r_arr[5];
-    let __v_171: G = __r_arr[6];
-    let __v_172: G = __r_arr[7];
-    let __v_173: G = __r_arr[8];
-    let __v_174: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_174]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_175: G = __r_arr[0];
-    let __v_176: G = __r_arr[1];
-    let __v_177: G = __r_arr[2];
-    let __v_178: G = __r_arr[3];
-    let __v_179: G = __r_arr[4];
-    let __v_180: G = __r_arr[5];
-    let __v_181: G = __r_arr[6];
-    let __v_182: G = __r_arr[7];
-    let __v_183: G = __r_arr[8];
-    let __v_184: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_184]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_185: G = __r_arr[0];
-    let __v_186: G = __r_arr[1];
-    let __v_187: G = __r_arr[2];
-    let __v_188: G = __r_arr[3];
-    let __v_189: G = __r_arr[4];
-    let __v_190: G = __r_arr[5];
-    let __v_191: G = __r_arr[6];
-    let __v_192: G = __r_arr[7];
-    let __v_193: G = __r_arr[8];
-    let __v_194: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_194]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_195: G = __r_arr[0];
-    let __v_196: G = __r_arr[1];
-    let __v_197: G = __r_arr[2];
-    let __v_198: G = __r_arr[3];
-    let __v_199: G = __r_arr[4];
-    let __v_200: G = __r_arr[5];
-    let __v_201: G = __r_arr[6];
-    let __v_202: G = __r_arr[7];
-    let __v_203: G = __r_arr[8];
-    let __v_204: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_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 = __r_arr[6];
-    let __v_212: G = __r_arr[7];
-    let __v_213: G = __r_arr[8];
-    let __v_214: G = __r_arr[9];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_214]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_215: G = __r_arr[0];
-    let __v_216: G = __r_arr[1];
-    let __v_217: G = __r_arr[2];
-    let __v_218: G = __r_arr[3];
-    let __v_219: G = __r_arr[4];
-    let __v_220: G = __r_arr[5];
-    let __v_221: G = __r_arr[6];
-    let __v_222: G = __r_arr[7];
-    let __v_223: G = __r_arr[8];
-    let __v_224: G = __r_arr[9];
-    let __v_225: G = G::from_u64(0);
-    let __v_226: G = G::from_u64(0);
-    let __v_227: G = G::from_u64(0);
-    let __v_228: G = G::from_u64(0);
+    let __v_117: G = G::from_u64(0);
+    let __v_118: G = G::from_u64(0);
+    let __v_119: G = G::from_u64(0);
+    let __v_120: G = G::from_u64(0);
+    let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_122: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_123: G = G::from_u64(1);
+    let __v_124: G = G::from_u64(1);
+    let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_126: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_126]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_127: G = __r_arr[0];
+    let __v_128: G = __r_arr[1];
+    let __v_129: G = __r_arr[2];
+    let __v_130: G = __r_arr[3];
+    let __v_131: G = __r_arr[4];
+    let __v_132: G = __r_arr[5];
+    let __v_133: G = __r_arr[6];
+    let __v_134: G = __r_arr[7];
+    let __v_135: G = __r_arr[8];
+    let __v_136: G = __r_arr[9];
+    let __v_137: G = __r_arr[10];
+    let __v_138: G = __r_arr[11];
+    let __v_139: G = __r_arr[12];
+    let __v_140: G = __r_arr[13];
+    let __v_141: G = __r_arr[14];
+    let __v_142: G = __r_arr[15];
+    let __v_143: G = __r_arr[16];
+    let __v_144: G = __r_arr[17];
+    let __v_145: G = __r_arr[18];
+    let __v_146: G = __r_arr[19];
+    let __v_147: G = __r_arr[20];
+    let __v_148: G = __r_arr[21];
+    let __v_149: G = __r_arr[22];
+    let __v_150: G = __r_arr[23];
+    let __v_151: G = __r_arr[24];
+    let __v_152: G = __r_arr[25];
+    let __v_153: G = __r_arr[26];
+    let __v_154: G = __r_arr[27];
+    let __v_155: G = __r_arr[28];
+    let __v_156: G = __r_arr[29];
+    let __v_157: G = __r_arr[30];
+    let __v_158: G = __r_arr[31];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_75]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_159: G = __r_arr[0];
+    let __v_160: G = __r_arr[1];
+    let __v_161: G = __r_arr[2];
+    let __v_162: G = __r_arr[3];
+    let __v_163: G = __r_arr[4];
+    let __v_164: G = __r_arr[5];
+    let __v_165: G = __r_arr[6];
+    let __v_166: G = __r_arr[7];
+    let __v_167: G = __r_arr[8];
+    let __v_168: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_168]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_169: G = __r_arr[0];
+    let __v_170: G = __r_arr[1];
+    let __v_171: G = __r_arr[2];
+    let __v_172: G = __r_arr[3];
+    let __v_173: G = __r_arr[4];
+    let __v_174: G = __r_arr[5];
+    let __v_175: G = __r_arr[6];
+    let __v_176: G = __r_arr[7];
+    let __v_177: G = __r_arr[8];
+    let __v_178: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_178]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_179: G = __r_arr[0];
+    let __v_180: G = __r_arr[1];
+    let __v_181: G = __r_arr[2];
+    let __v_182: G = __r_arr[3];
+    let __v_183: G = __r_arr[4];
+    let __v_184: G = __r_arr[5];
+    let __v_185: G = __r_arr[6];
+    let __v_186: G = __r_arr[7];
+    let __v_187: G = __r_arr[8];
+    let __v_188: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_188]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_189: G = __r_arr[0];
+    let __v_190: G = __r_arr[1];
+    let __v_191: G = __r_arr[2];
+    let __v_192: G = __r_arr[3];
+    let __v_193: G = __r_arr[4];
+    let __v_194: G = __r_arr[5];
+    let __v_195: G = __r_arr[6];
+    let __v_196: G = __r_arr[7];
+    let __v_197: G = __r_arr[8];
+    let __v_198: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_199: G = __r_arr[0];
+    let __v_200: G = __r_arr[1];
+    let __v_201: G = __r_arr[2];
+    let __v_202: G = __r_arr[3];
+    let __v_203: G = __r_arr[4];
+    let __v_204: G = __r_arr[5];
+    let __v_205: G = __r_arr[6];
+    let __v_206: G = __r_arr[7];
+    let __v_207: G = __r_arr[8];
+    let __v_208: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_208]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_209: G = __r_arr[0];
+    let __v_210: G = __r_arr[1];
+    let __v_211: G = __r_arr[2];
+    let __v_212: G = __r_arr[3];
+    let __v_213: G = __r_arr[4];
+    let __v_214: G = __r_arr[5];
+    let __v_215: G = __r_arr[6];
+    let __v_216: G = __r_arr[7];
+    let __v_217: G = __r_arr[8];
+    let __v_218: G = __r_arr[9];
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_218]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_219: G = __r_arr[0];
+    let __v_220: G = __r_arr[1];
+    let __v_221: G = __r_arr[2];
+    let __v_222: G = __r_arr[3];
+    let __v_223: G = __r_arr[4];
+    let __v_224: G = __r_arr[5];
+    let __v_225: G = __r_arr[6];
+    let __v_226: G = __r_arr[7];
+    let __v_227: G = __r_arr[8];
+    let __v_228: G = __r_arr[9];
     let __v_229: G = G::from_u64(0);
     let __v_230: G = G::from_u64(0);
-    let __v_231: G = G::from_u64(0);
-    let __v_232: G = G::from_u64(1);
-    let __v_233: G = G::from_u64(1);
-    let __v_234: G = { let __values: [G; 10] = [__v_232, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233, __v_233]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_235: G = { let __values: [G; 10] = [__v_231, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_234]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_236: G = { let __values: [G; 10] = [__v_230, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_235]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_237: G = { let __values: [G; 10] = [__v_229, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_236]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_238: G = { let __values: [G; 10] = [__v_228, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_239: G = { let __values: [G; 10] = [__v_227, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_240: G = { let __values: [G; 10] = [__v_226, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_241: G = { let __values: [G; 10] = [__v_225, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_224]; let __cu = unconstrained; if let Some(result) = record.function_queries[77].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_77(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_77] = unsafe { *(result.output.as_ptr() as *const [G; OUT_77]) }; __ret } } else { aiur_fn_77(__args, record, io_buffer, __cu)? } };
-    let __v_242: G = __r_arr[0];
-    let __v_243: G = __r_arr[1];
-    let __v_244: G = __r_arr[2];
-    let __v_245: G = __r_arr[3];
-    let __v_246: G = __r_arr[4];
-    let __v_247: G = __r_arr[5];
-    let __v_248: G = __r_arr[6];
-    let __v_249: G = __r_arr[7];
-    let __v_250: G = __r_arr[8];
-    let __v_251: G = __r_arr[9];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_251, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_90(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } } else { aiur_fn_90(__args, record, io_buffer, __cu)? } };
-    let __v_252: G = __r_arr[0];
-    let __v_253: G = __r_arr[1];
-    let __v_254: G = __r_arr[2];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_254]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_91(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } } else { aiur_fn_91(__args, record, io_buffer, __cu)? } };
-    let __v_255: G = __r_arr[0];
-    let __v_256: G = __r_arr[1];
-    let __v_257: G = __r_arr[2];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_257, __v_242]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_92(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } } else { aiur_fn_92(__args, record, io_buffer, __cu)? } };
-    let __v_258: G = __r_arr[0];
-    let __v_259: G = __r_arr[1];
-    let __v_260: G = G::from_u64(0);
-    let __v_261: G = { let __values: [G; 10] = [__v_260, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_253]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_241, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+    let __v_231: G = G::from_u64(0);
+    let __v_232: G = G::from_u64(0);
+    let __v_233: G = G::from_u64(0);
+    let __v_234: G = G::from_u64(0);
+    let __v_235: G = G::from_u64(0);
+    let __v_236: G = G::from_u64(1);
+    let __v_237: G = G::from_u64(1);
+    let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_240: G = { let __values: [G; 10] = [__v_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_241: G = { let __values: [G; 10] = [__v_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_245: G = { let __values: [G; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_228]; 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 { let __r = record.function_queries[80].replay_at(__i); record.virt += __r; } 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_246: G = __r_arr[0];
+    let __v_247: G = __r_arr[1];
+    let __v_248: G = __r_arr[2];
+    let __v_249: G = __r_arr[3];
+    let __v_250: G = __r_arr[4];
+    let __v_251: G = __r_arr[5];
+    let __v_252: G = __r_arr[6];
+    let __v_253: G = __r_arr[7];
+    let __v_254: G = __r_arr[8];
+    let __v_255: G = __r_arr[9];
+    let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_255, __v_246]; 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 { let __r = record.function_queries[93].replay_at(__i); record.virt += __r; } 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_256: G = __r_arr[0];
+    let __v_257: G = __r_arr[1];
+    let __v_258: G = __r_arr[2];
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_258]; 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 { let __r = record.function_queries[94].replay_at(__i); record.virt += __r; } 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_259: G = __r_arr[0];
+    let __v_260: G = __r_arr[1];
+    let __v_261: G = __r_arr[2];
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_261, __v_246]; 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 { let __r = record.function_queries[95].replay_at(__i); record.virt += __r; } 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_262: G = __r_arr[0];
-    let __v_263: G = G::from_u64(2);
-    let __v_264: G = G::from_u64(0);
-    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_264]; let __info = io_buffer.get_info(__v_263, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
-    let __v_265: G = __io_pair.0;
-    let __v_266: G = __io_pair.1;
-    let __v_267: G = G::from_u64(2);
-    let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_267, __v_265, __v_266]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_0(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } } else { aiur_fn_0(__args, record, io_buffer, __cu)? } };
-    let __v_268: G = __r_arr[0];
-    let __v_269: G = G::from_u64(103);
-    let __v_270: G = G::from_u64(230);
-    let __v_271: G = G::from_u64(9);
-    let __v_272: G = G::from_u64(106);
-    let __v_273: G = G::from_u64(133);
-    let __v_274: G = G::from_u64(174);
-    let __v_275: G = G::from_u64(103);
-    let __v_276: G = G::from_u64(187);
-    let __v_277: G = G::from_u64(114);
-    let __v_278: G = G::from_u64(243);
-    let __v_279: G = G::from_u64(110);
-    let __v_280: G = G::from_u64(60);
-    let __v_281: G = G::from_u64(58);
-    let __v_282: G = G::from_u64(245);
-    let __v_283: G = G::from_u64(79);
-    let __v_284: G = G::from_u64(165);
-    let __v_285: G = G::from_u64(127);
-    let __v_286: G = G::from_u64(82);
-    let __v_287: G = G::from_u64(14);
-    let __v_288: G = G::from_u64(81);
-    let __v_289: G = G::from_u64(140);
-    let __v_290: G = G::from_u64(104);
-    let __v_291: G = G::from_u64(5);
-    let __v_292: G = G::from_u64(155);
-    let __v_293: G = G::from_u64(171);
-    let __v_294: G = G::from_u64(217);
-    let __v_295: G = G::from_u64(131);
-    let __v_296: G = G::from_u64(31);
-    let __v_297: G = G::from_u64(25);
-    let __v_298: G = G::from_u64(205);
-    let __v_299: G = G::from_u64(224);
-    let __v_300: G = G::from_u64(91);
-    let __v_301: G = G::from_u64(1);
-    let __v_302: G = G::from_u64(1);
-    let __v_303: G = { let __values: [G; 3] = [__v_301, __v_302, __v_302]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_304: G = G::from_u64(0);
-    let __v_305: G = G::from_u64(0);
-    let __v_306: G = G::from_u64(0);
-    let __v_307: G = G::from_u64(0);
-    let __v_308: G = G::from_u64(0);
-    let __v_309: G = G::from_u64(0);
+    let __v_263: G = __r_arr[1];
+    let __v_264: G = G::from_u64(1);
+    let __gb: [u8; 8] = __v_264.as_canonical_u64().to_le_bytes();
+    let __v_265: G = G::from_u8(__gb[0]);
+    let __v_266: G = G::from_u8(__gb[1]);
+    let __v_267: G = G::from_u8(__gb[2]);
+    let __v_268: G = G::from_u8(__gb[3]);
+    let __v_269: G = G::from_u8(__gb[4]);
+    let __v_270: G = G::from_u8(__gb[5]);
+    let __v_271: G = G::from_u8(__gb[6]);
+    let __v_272: G = G::from_u8(__gb[7]);
+    if !unconstrained { let __vi = __v_265; let __vj = __v_266; 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_267; let __vj = __v_268; 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_269; let __vj = __v_270; 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_271; let __vj = __v_272; 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_273: G = G::from_u64(1020);
+    let __v_274: G = (__v_272 - __v_273);
+    let __v_275: G = (__v_271 + __v_274);
+    let __v_276: G = (__v_270 + __v_275);
+    let __v_277: G = (__v_269 + __v_276);
+    let __v_278: G = G::from_bool((__v_277 == G::ZERO));
+    let __v_279: G = (__v_267 + __v_268);
+    let __v_280: G = (__v_266 + __v_279);
+    let __v_281: G = (__v_265 + __v_280);
+    let __v_282: G = G::from_bool((__v_281 == G::ZERO));
+    let __v_283: G = G::from_u64(256);
+    let __v_284: G = (__v_283 * __v_266);
+    let __v_285: G = G::from_u64(65536);
+    let __v_286: G = (__v_285 * __v_267);
+    let __v_287: G = G::from_u64(16777216);
+    let __v_288: G = (__v_287 * __v_268);
+    let __v_289: G = G::from_u64(4294967296);
+    let __v_290: G = (__v_289 * __v_269);
+    let __v_291: G = G::from_u64(1099511627776);
+    let __v_292: G = (__v_291 * __v_270);
+    let __v_293: G = G::from_u64(281474976710656);
+    let __v_294: G = (__v_293 * __v_271);
+    let __v_295: G = G::from_u64(72057594037927936);
+    let __v_296: G = (__v_295 * __v_272);
+    let __v_297: G = (__v_294 + __v_296);
+    let __v_298: G = (__v_292 + __v_297);
+    let __v_299: G = (__v_290 + __v_298);
+    let __v_300: G = (__v_288 + __v_299);
+    let __v_301: G = (__v_286 + __v_300);
+    let __v_302: G = (__v_284 + __v_301);
+    let __v_303: G = (__v_265 + __v_302);
+    if (__v_303 != __v_264) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_303.as_canonical_u64(), rhs: __v_264.as_canonical_u64(), msg: None });
+    }
+    let __v_304: G = G::from_u64(1);
+    let __v_305: G = G::from_u64(1);
+    let __v_306: G = (__v_305 - __v_282);
+    let __v_307: G = (__v_278 * __v_306);
+    let __v_308: G = (__v_304 - __v_307);
+    let __v_309: G = G::from_u64(1);
+    if (__v_308 != __v_309) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: None });
+    }
     let __v_310: G = G::from_u64(0);
     let __v_311: G = G::from_u64(0);
-    let __v_312: G = G::from_u64(0);
-    let __v_313: G = G::from_u64(0);
-    let __v_314: G = { let __values: [G; 8] = [__v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_315: G = { let __values: [G; 32] = [__v_269, __v_270, __v_271, __v_272, __v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __v_316: G = G::from_u64(1);
-    let __v_317: G = G::from_u64(1);
-    let __v_318: G = { let __values: [G; 34] = [__v_316, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317, __v_317]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_268, __v_303, __v_304, __v_305, __v_314, __v_315, __v_318]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_65(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } } else { aiur_fn_65(__args, record, io_buffer, __cu)? } };
-    let __v_319: G = __r_arr[0];
-    let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_319]; let __cu = unconstrained; if let Some(result) = record.function_queries[64].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_64(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } } else { aiur_fn_64(__args, record, io_buffer, __cu)? } };
+    let __v_312: G = { let __values: [G; 10] = [__v_311, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_313: G = { let __values: [G; 10] = [__v_310, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_312]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_245, __v_313]; 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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_314: G = __r_arr[0];
+    let __v_315: G = G::from_u64(2);
+    let __v_316: G = G::from_u64(0);
+    let __io_pair: (G, G) = { let __key: [G; 1] = [__v_316]; let __info = io_buffer.get_info(__v_315, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) };
+    let __v_317: G = __io_pair.0;
+    let __v_318: G = __io_pair.1;
+    let __v_319: G = G::from_u64(2);
+    let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_319, __v_317, __v_318]; 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_320: G = __r_arr[0];
-    let __v_321: G = __r_arr[1];
-    let __v_322: G = __r_arr[2];
-    let __v_323: G = __r_arr[3];
-    let __v_324: G = __r_arr[4];
-    let __v_325: G = __r_arr[5];
-    let __v_326: G = __r_arr[6];
-    let __v_327: G = __r_arr[7];
-    let __v_328: G = __r_arr[8];
-    let __v_329: G = __r_arr[9];
-    let __v_330: G = __r_arr[10];
-    let __v_331: G = __r_arr[11];
-    let __v_332: G = __r_arr[12];
-    let __v_333: G = __r_arr[13];
-    let __v_334: G = __r_arr[14];
-    let __v_335: G = __r_arr[15];
-    let __v_336: G = __r_arr[16];
-    let __v_337: G = __r_arr[17];
-    let __v_338: G = __r_arr[18];
-    let __v_339: G = __r_arr[19];
-    let __v_340: G = __r_arr[20];
-    let __v_341: G = __r_arr[21];
-    let __v_342: G = __r_arr[22];
-    let __v_343: G = __r_arr[23];
-    let __v_344: G = __r_arr[24];
-    let __v_345: G = __r_arr[25];
-    let __v_346: G = __r_arr[26];
-    let __v_347: G = __r_arr[27];
-    let __v_348: G = __r_arr[28];
-    let __v_349: G = __r_arr[29];
-    let __v_350: G = __r_arr[30];
-    let __v_351: G = __r_arr[31];
-    let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_24(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } } else { aiur_fn_24(__args, record, io_buffer, __cu)? } };
-    let __v_352: G = __r_arr[0];
-    let __v_353: G = __r_arr[1];
-    let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_353, __v_352]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } };
-    let __v_354: G = __r_arr[0];
-    let __v_355: G = __r_arr[1];
+    let __v_321: G = G::from_u64(103);
+    let __v_322: G = G::from_u64(230);
+    let __v_323: G = G::from_u64(9);
+    let __v_324: G = G::from_u64(106);
+    let __v_325: G = G::from_u64(133);
+    let __v_326: G = G::from_u64(174);
+    let __v_327: G = G::from_u64(103);
+    let __v_328: G = G::from_u64(187);
+    let __v_329: G = G::from_u64(114);
+    let __v_330: G = G::from_u64(243);
+    let __v_331: G = G::from_u64(110);
+    let __v_332: G = G::from_u64(60);
+    let __v_333: G = G::from_u64(58);
+    let __v_334: G = G::from_u64(245);
+    let __v_335: G = G::from_u64(79);
+    let __v_336: G = G::from_u64(165);
+    let __v_337: G = G::from_u64(127);
+    let __v_338: G = G::from_u64(82);
+    let __v_339: G = G::from_u64(14);
+    let __v_340: G = G::from_u64(81);
+    let __v_341: G = G::from_u64(140);
+    let __v_342: G = G::from_u64(104);
+    let __v_343: G = G::from_u64(5);
+    let __v_344: G = G::from_u64(155);
+    let __v_345: G = G::from_u64(171);
+    let __v_346: G = G::from_u64(217);
+    let __v_347: G = G::from_u64(131);
+    let __v_348: G = G::from_u64(31);
+    let __v_349: G = G::from_u64(25);
+    let __v_350: G = G::from_u64(205);
+    let __v_351: G = G::from_u64(224);
+    let __v_352: G = G::from_u64(91);
+    let __v_353: G = G::from_u64(1);
+    let __v_354: G = G::from_u64(1);
+    let __v_355: G = { let __values: [G; 3] = [__v_353, __v_354, __v_354]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_356: G = G::from_u64(0);
+    let __v_357: G = G::from_u64(0);
+    let __v_358: G = G::from_u64(0);
+    let __v_359: G = G::from_u64(0);
+    let __v_360: G = G::from_u64(0);
+    let __v_361: G = G::from_u64(0);
+    let __v_362: G = G::from_u64(0);
+    let __v_363: G = G::from_u64(0);
+    let __v_364: G = G::from_u64(0);
+    let __v_365: G = G::from_u64(0);
+    let __v_366: G = { let __values: [G; 8] = [__v_358, __v_359, __v_360, __v_361, __v_362, __v_363, __v_364, __v_365]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_367: G = { let __values: [G; 32] = [__v_321, __v_322, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_331, __v_332, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_341, __v_342, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_351, __v_352]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __v_368: G = G::from_u64(1);
+    let __v_369: G = G::from_u64(1);
+    let __v_370: G = { let __values: [G; 34] = [__v_368, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369, __v_369]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_320, __v_355, __v_356, __v_357, __v_366, __v_367, __v_370]; 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 { let __r = record.function_queries[68].replay_at(__i); record.virt += __r; } 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_371: G = __r_arr[0];
+    let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_371]; 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 { let __r = record.function_queries[67].replay_at(__i); record.virt += __r; } 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_372: G = __r_arr[0];
+    let __v_373: G = __r_arr[1];
+    let __v_374: G = __r_arr[2];
+    let __v_375: G = __r_arr[3];
+    let __v_376: G = __r_arr[4];
+    let __v_377: G = __r_arr[5];
+    let __v_378: G = __r_arr[6];
+    let __v_379: G = __r_arr[7];
+    let __v_380: G = __r_arr[8];
+    let __v_381: G = __r_arr[9];
+    let __v_382: G = __r_arr[10];
+    let __v_383: G = __r_arr[11];
+    let __v_384: G = __r_arr[12];
+    let __v_385: G = __r_arr[13];
+    let __v_386: G = __r_arr[14];
+    let __v_387: G = __r_arr[15];
+    let __v_388: G = __r_arr[16];
+    let __v_389: G = __r_arr[17];
+    let __v_390: G = __r_arr[18];
+    let __v_391: G = __r_arr[19];
+    let __v_392: G = __r_arr[20];
+    let __v_393: G = __r_arr[21];
+    let __v_394: G = __r_arr[22];
+    let __v_395: G = __r_arr[23];
+    let __v_396: G = __r_arr[24];
+    let __v_397: G = __r_arr[25];
+    let __v_398: G = __r_arr[26];
+    let __v_399: G = __r_arr[27];
+    let __v_400: G = __r_arr[28];
+    let __v_401: G = __r_arr[29];
+    let __v_402: G = __r_arr[30];
+    let __v_403: G = __r_arr[31];
+    let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_320]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { let __r = record.function_queries[27].replay_at(__i); record.virt += __r; } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } };
+    let __v_404: G = __r_arr[0];
+    let __v_405: G = __r_arr[1];
+    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_405, __v_404]; 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 { let __r = record.function_queries[203].replay_at(__i); record.virt += __r; } 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_406: G = __r_arr[0];
+    let __v_407: G = __r_arr[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() {
   _ => {
-    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-    let __v_356: G = __r_arr[0];
-    let __v_357: G = G::from_bool((__v_356 == G::ZERO));
-    let __v_358: G = G::from_u64(0);
-    if (__v_357 != __v_358) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None });
-    }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_359: G = __r_arr[0];
-    if (__v_359 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_359.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
-    }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_360: G = __r_arr[0];
-    if (__v_360 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_360.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
-    }
-    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-    let __v_361: G = __r_arr[0];
-    if (__v_361 != __v_356) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: None });
-    }
-    let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } };
-    let __v_362: G = __r_arr[0];
-    let __v_363: G = G::from_u64(1);
-    if (__v_362 != __v_363) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_362.as_canonical_u64(), rhs: __v_363.as_canonical_u64(), msg: None });
-    }
-    let __v_364: G = G::from_u64(1);
-    break '__mc_0 [__v_364];
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_408: G = __r_arr[0];
+    let __v_409: G = G::from_bool((__v_408 == G::ZERO));
+    let __v_410: G = G::from_u64(0);
+    if (__v_409 != __v_410) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_66]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_411: G = __r_arr[0];
+    if (__v_411 != __v_408) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_68]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_412: G = __r_arr[0];
+    if (__v_412 != __v_408) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_61]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_413: G = __r_arr[0];
+    if (__v_413 != __v_408) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_413.as_canonical_u64(), rhs: __v_408.as_canonical_u64(), msg: None });
+    }
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_30]; 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 { let __r = record.function_queries[160].replay_at(__i); record.virt += __r; } 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_414: G = __r_arr[0];
+    let __v_415: G = G::from_u64(1);
+    if (__v_414 != __v_415) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_414.as_canonical_u64(), rhs: __v_415.as_canonical_u64(), msg: None });
+    }
+    let __v_416: G = G::from_u64(1);
+    break '__mc_0 [__v_416];
   },
 }
  };
-    let __v_356: G = __mc_out___mc_0[0];
-    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_155.as_canonical_u64() {
+    let __v_408: G = __mc_out___mc_0[0];
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_159.as_canonical_u64() {
   _ => {
-    match __v_155.as_canonical_u64() {
+    match __v_159.as_canonical_u64() {
       _ => {
         match __v_22.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_252, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } };
-            let __v_357: G = __r_arr[0];
-            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_258, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } };
-            let __v_358: G = __r_arr[0];
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_256, __v_22]; 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 { let __r = record.function_queries[200].replay_at(__i); record.virt += __r; } 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_409: G = __r_arr[0];
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_262, __v_22]; 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 { let __r = record.function_queries[201].replay_at(__i); record.virt += __r; } 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_410: G = __r_arr[0];
             match __v_24.as_canonical_u64() {
               _ => {
-                let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_255.as_canonical_u64() {
+                let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_259.as_canonical_u64() {
   0u64 => {
-    let __v_359: G = G::from_u64(1);
-    let __v_360: G = G::from_u64(1);
-    let __v_361: G = { let __values: [G; 3] = [__v_359, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    break '__mc_2 [__v_361];
+    let __v_411: G = G::from_u64(1);
+    let __v_412: G = G::from_u64(1);
+    let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+    break '__mc_2 [__v_413];
   },
   1u64 => {
-    break '__mc_2 [__v_256];
+    break '__mc_2 [__v_260];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_255.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_259.as_canonical_u64()));
   },
 }
  };
-                let __v_359: G = __mc_out___mc_2[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_34, __v_268]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_360: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_24, __v_360]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_361: G = __r_arr[0];
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_359, __v_361]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } };
-                let __v_362: G = __r_arr[0];
-                let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_22, __v_362]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } };
-                let __v_363: G = __r_arr[0];
-                let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_262, __v_363]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } };
-                let __v_364: G = __r_arr[0];
-                let __v_365: G = G::from_u64(0);
-                let __v_366: G = G::from_u64(109);
-                let __v_367: G = G::from_u64(0);
-                let __v_368: G = G::from_u64(117);
-                let __v_369: G = G::from_u64(0);
-                let __v_370: G = G::from_u64(108);
-                let __v_371: G = G::from_u64(0);
-                let __v_372: G = G::from_u64(116);
-                let __v_373: G = G::from_u64(0);
-                let __v_374: G = G::from_u64(105);
-                let __v_375: G = G::from_u64(0);
-                let __v_376: G = G::from_u64(45);
-                let __v_377: G = G::from_u64(0);
-                let __v_378: G = G::from_u64(115);
-                let __v_379: G = G::from_u64(0);
-                let __v_380: G = G::from_u64(116);
-                let __v_381: G = G::from_u64(0);
-                let __v_382: G = G::from_u64(97);
-                let __v_383: G = G::from_u64(0);
-                let __v_384: G = G::from_u64(114);
-                let __v_385: G = G::from_u64(0);
-                let __v_386: G = G::from_u64(107);
-                let __v_387: G = G::from_u64(0);
-                let __v_388: G = G::from_u64(47);
-                let __v_389: G = G::from_u64(0);
-                let __v_390: G = G::from_u64(118);
-                let __v_391: G = G::from_u64(0);
-                let __v_392: G = G::from_u64(48);
-                let __v_393: G = { let __values: [G; 3] = [__v_391, __v_392, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_394: G = { let __values: [G; 3] = [__v_389, __v_390, __v_393]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_395: G = { let __values: [G; 3] = [__v_387, __v_388, __v_394]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_396: G = { let __values: [G; 3] = [__v_385, __v_386, __v_395]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_397: G = { let __values: [G; 3] = [__v_383, __v_384, __v_396]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_398: G = { let __values: [G; 3] = [__v_381, __v_382, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_399: G = { let __values: [G; 3] = [__v_379, __v_380, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_400: G = { let __values: [G; 3] = [__v_377, __v_378, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_401: G = { let __values: [G; 3] = [__v_375, __v_376, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_402: G = { let __values: [G; 3] = [__v_373, __v_374, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_403: G = { let __values: [G; 3] = [__v_371, __v_372, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_404: G = { let __values: [G; 3] = [__v_369, __v_370, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_405: G = { let __values: [G; 3] = [__v_367, __v_368, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_406: G = { let __values: [G; 3] = [__v_365, __v_366, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __v_407: G = G::from_u64(1);
-                let __v_408: G = G::from_u64(1);
-                let __v_409: G = { let __values: [G; 3] = [__v_407, __v_408, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_406, __v_409]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_410: G = __r_arr[0];
-                let __v_411: G = __r_arr[1];
-                let __v_412: G = __r_arr[2];
-                let __v_413: G = __r_arr[3];
-                let __v_414: G = __r_arr[4];
-                let __v_415: G = __r_arr[5];
-                let __v_416: G = __r_arr[6];
-                let __v_417: G = __r_arr[7];
-                let __v_418: G = __r_arr[8];
-                let __v_419: G = __r_arr[9];
-                let __v_420: G = __r_arr[10];
-                let __v_421: G = __r_arr[11];
-                let __v_422: G = __r_arr[12];
-                let __v_423: G = __r_arr[13];
-                let __v_424: G = __r_arr[14];
-                let __v_425: G = __r_arr[15];
-                let __v_426: G = __r_arr[16];
-                let __v_427: G = __r_arr[17];
-                let __v_428: G = G::from_u64(1);
-                let __v_429: G = G::from_u64(1);
-                let __v_430: G = { let __values: [G; 3] = [__v_428, __v_429, __v_429]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_430]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_431: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_431]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_432: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_426, __v_432]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_433: G = __r_arr[0];
-                let __v_434: G = G::from_u64(1);
-                let __v_435: G = G::from_u64(1);
-                let __v_436: G = { let __values: [G; 3] = [__v_434, __v_435, __v_435]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_433, __v_436]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_437: G = __r_arr[0];
-                let __v_438: G = __r_arr[1];
-                let __v_439: G = __r_arr[2];
-                let __v_440: G = __r_arr[3];
-                let __v_441: G = __r_arr[4];
-                let __v_442: G = __r_arr[5];
-                let __v_443: G = __r_arr[6];
-                let __v_444: G = __r_arr[7];
-                let __v_445: G = __r_arr[8];
-                let __v_446: G = __r_arr[9];
-                let __v_447: G = __r_arr[10];
-                let __v_448: G = __r_arr[11];
-                let __v_449: G = __r_arr[12];
-                let __v_450: G = __r_arr[13];
-                let __v_451: G = __r_arr[14];
-                let __v_452: G = __r_arr[15];
-                let __v_453: G = __r_arr[16];
-                let __v_454: G = __r_arr[17];
-                let __v_455: G = G::from_u64(1);
-                let __v_456: G = G::from_u64(1);
-                let __v_457: G = { let __values: [G; 3] = [__v_455, __v_456, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_445, __v_446, __v_447, __v_448, __v_449, __v_450, __v_451, __v_452, __v_457]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_458: G = __r_arr[0];
-                let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_458]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } };
-                let __v_459: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_453, __v_459]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_460: G = __r_arr[0];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_460, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_461: G = __r_arr[0];
-                let __v_462: G = G::from_u64(1);
-                let __v_463: G = G::from_u64(1);
-                let __v_464: G = { let __values: [G; 3] = [__v_462, __v_463, __v_463]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_30, __v_464]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                let __v_465: G = __r_arr[0];
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_461, __v_465]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                let __v_466: G = __r_arr[0];
-                let __v_467: G = G::from_u64(1);
-                let __v_468: G = G::from_u64(1);
-                let __v_469: G = { let __values: [G; 3] = [__v_467, __v_468, __v_468]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_466, __v_469]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_470: G = __r_arr[0];
-                let __v_471: G = __r_arr[1];
-                let __v_472: G = __r_arr[2];
-                let __v_473: G = __r_arr[3];
-                let __v_474: G = __r_arr[4];
-                let __v_475: G = __r_arr[5];
-                let __v_476: G = __r_arr[6];
-                let __v_477: G = __r_arr[7];
-                let __v_478: G = __r_arr[8];
-                let __v_479: G = __r_arr[9];
-                let __v_480: G = __r_arr[10];
-                let __v_481: G = __r_arr[11];
-                let __v_482: G = __r_arr[12];
-                let __v_483: G = __r_arr[13];
-                let __v_484: G = __r_arr[14];
-                let __v_485: G = __r_arr[15];
-                let __v_486: G = __r_arr[16];
-                let __v_487: G = __r_arr[17];
-                let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_486, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } };
-                let __v_488: G = __r_arr[0];
-                let __v_489: G = G::from_u64(1);
-                let __v_490: G = G::from_u64(1);
-                let __v_491: G = { let __values: [G; 3] = [__v_489, __v_490, __v_490]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_488, __v_491]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                let __v_492: G = __r_arr[0];
-                let __v_493: G = __r_arr[1];
-                let __v_494: G = __r_arr[2];
-                let __v_495: G = __r_arr[3];
-                let __v_496: G = __r_arr[4];
-                let __v_497: G = __r_arr[5];
-                let __v_498: G = __r_arr[6];
-                let __v_499: G = __r_arr[7];
-                let __v_500: G = __r_arr[8];
-                let __v_501: G = __r_arr[9];
-                let __v_502: G = __r_arr[10];
-                let __v_503: G = __r_arr[11];
-                let __v_504: G = __r_arr[12];
-                let __v_505: G = __r_arr[13];
-                let __v_506: G = __r_arr[14];
-                let __v_507: G = __r_arr[15];
-                let __v_508: G = __r_arr[16];
-                let __v_509: G = __r_arr[17];
-                let __v_510: G = G::from_u64(256);
-                let __v_511: G = (__v_510 * __v_411);
-                let __v_512: G = G::from_u64(65536);
-                let __v_513: G = (__v_512 * __v_412);
-                let __v_514: G = G::from_u64(16777216);
-                let __v_515: G = (__v_514 * __v_413);
-                let __v_516: G = G::from_u64(4294967296);
-                let __v_517: G = (__v_516 * __v_414);
-                let __v_518: G = G::from_u64(1099511627776);
-                let __v_519: G = (__v_518 * __v_415);
-                let __v_520: G = G::from_u64(281474976710656);
-                let __v_521: G = (__v_520 * __v_416);
-                let __v_522: G = G::from_u64(72057594037927936);
-                let __v_523: G = (__v_522 * __v_417);
-                let __v_524: G = (__v_521 + __v_523);
-                let __v_525: G = (__v_519 + __v_524);
-                let __v_526: G = (__v_517 + __v_525);
-                let __v_527: G = (__v_515 + __v_526);
-                let __v_528: G = (__v_513 + __v_527);
-                let __v_529: G = (__v_511 + __v_528);
-                let __v_530: G = (__v_410 + __v_529);
-                let __v_531: G = G::from_u64(256);
-                let __v_532: G = (__v_531 * __v_419);
-                let __v_533: G = G::from_u64(65536);
-                let __v_534: G = (__v_533 * __v_420);
-                let __v_535: G = G::from_u64(16777216);
-                let __v_536: G = (__v_535 * __v_421);
-                let __v_537: G = G::from_u64(4294967296);
-                let __v_538: G = (__v_537 * __v_422);
-                let __v_539: G = G::from_u64(1099511627776);
-                let __v_540: G = (__v_539 * __v_423);
-                let __v_541: G = G::from_u64(281474976710656);
-                let __v_542: G = (__v_541 * __v_424);
-                let __v_543: G = G::from_u64(72057594037927936);
-                let __v_544: G = (__v_543 * __v_425);
-                let __v_545: G = (__v_542 + __v_544);
-                let __v_546: G = (__v_540 + __v_545);
-                let __v_547: G = (__v_538 + __v_546);
-                let __v_548: G = (__v_536 + __v_547);
-                let __v_549: G = (__v_534 + __v_548);
-                let __v_550: G = (__v_532 + __v_549);
-                let __v_551: G = (__v_418 + __v_550);
-                let __v_552: G = G::from_u64(256);
-                let __v_553: G = (__v_552 * __v_438);
-                let __v_554: G = G::from_u64(65536);
-                let __v_555: G = (__v_554 * __v_439);
-                let __v_556: G = G::from_u64(16777216);
-                let __v_557: G = (__v_556 * __v_440);
-                let __v_558: G = G::from_u64(4294967296);
-                let __v_559: G = (__v_558 * __v_441);
-                let __v_560: G = G::from_u64(1099511627776);
-                let __v_561: G = (__v_560 * __v_442);
-                let __v_562: G = G::from_u64(281474976710656);
-                let __v_563: G = (__v_562 * __v_443);
-                let __v_564: G = G::from_u64(72057594037927936);
-                let __v_565: G = (__v_564 * __v_444);
-                let __v_566: G = (__v_563 + __v_565);
-                let __v_567: G = (__v_561 + __v_566);
-                let __v_568: G = (__v_559 + __v_567);
-                let __v_569: G = (__v_557 + __v_568);
-                let __v_570: G = (__v_555 + __v_569);
-                let __v_571: G = (__v_553 + __v_570);
-                let __v_572: G = (__v_437 + __v_571);
-                let __v_573: G = G::from_u64(256);
-                let __v_574: G = (__v_573 * __v_446);
-                let __v_575: G = G::from_u64(65536);
-                let __v_576: G = (__v_575 * __v_447);
-                let __v_577: G = G::from_u64(16777216);
-                let __v_578: G = (__v_577 * __v_448);
-                let __v_579: G = G::from_u64(4294967296);
-                let __v_580: G = (__v_579 * __v_449);
-                let __v_581: G = G::from_u64(1099511627776);
-                let __v_582: G = (__v_581 * __v_450);
-                let __v_583: G = G::from_u64(281474976710656);
-                let __v_584: G = (__v_583 * __v_451);
-                let __v_585: G = G::from_u64(72057594037927936);
-                let __v_586: G = (__v_585 * __v_452);
-                let __v_587: G = (__v_584 + __v_586);
-                let __v_588: G = (__v_582 + __v_587);
-                let __v_589: G = (__v_580 + __v_588);
-                let __v_590: G = (__v_578 + __v_589);
-                let __v_591: G = (__v_576 + __v_590);
-                let __v_592: G = (__v_574 + __v_591);
-                let __v_593: G = (__v_445 + __v_592);
-                let __v_594: G = G::from_u64(256);
-                let __v_595: G = (__v_594 * __v_471);
-                let __v_596: G = G::from_u64(65536);
-                let __v_597: G = (__v_596 * __v_472);
-                let __v_598: G = G::from_u64(16777216);
-                let __v_599: G = (__v_598 * __v_473);
-                let __v_600: G = G::from_u64(4294967296);
-                let __v_601: G = (__v_600 * __v_474);
-                let __v_602: G = G::from_u64(1099511627776);
-                let __v_603: G = (__v_602 * __v_475);
-                let __v_604: G = G::from_u64(281474976710656);
-                let __v_605: G = (__v_604 * __v_476);
-                let __v_606: G = G::from_u64(72057594037927936);
-                let __v_607: G = (__v_606 * __v_477);
-                let __v_608: G = (__v_605 + __v_607);
-                let __v_609: G = (__v_603 + __v_608);
-                let __v_610: G = (__v_601 + __v_609);
-                let __v_611: G = (__v_599 + __v_610);
-                let __v_612: G = (__v_597 + __v_611);
-                let __v_613: G = (__v_595 + __v_612);
-                let __v_614: G = (__v_470 + __v_613);
-                let __v_615: G = G::from_u64(256);
-                let __v_616: G = (__v_615 * __v_479);
-                let __v_617: G = G::from_u64(65536);
-                let __v_618: G = (__v_617 * __v_480);
-                let __v_619: G = G::from_u64(16777216);
-                let __v_620: G = (__v_619 * __v_481);
-                let __v_621: G = G::from_u64(4294967296);
-                let __v_622: G = (__v_621 * __v_482);
-                let __v_623: G = G::from_u64(1099511627776);
-                let __v_624: G = (__v_623 * __v_483);
-                let __v_625: G = G::from_u64(281474976710656);
-                let __v_626: G = (__v_625 * __v_484);
-                let __v_627: G = G::from_u64(72057594037927936);
-                let __v_628: G = (__v_627 * __v_485);
-                let __v_629: G = (__v_626 + __v_628);
-                let __v_630: G = (__v_624 + __v_629);
-                let __v_631: G = (__v_622 + __v_630);
-                let __v_632: G = (__v_620 + __v_631);
-                let __v_633: G = (__v_618 + __v_632);
-                let __v_634: G = (__v_616 + __v_633);
-                let __v_635: G = (__v_478 + __v_634);
-                let __v_636: G = G::from_u64(256);
-                let __v_637: G = (__v_636 * __v_493);
-                let __v_638: G = G::from_u64(65536);
-                let __v_639: G = (__v_638 * __v_494);
-                let __v_640: G = G::from_u64(16777216);
-                let __v_641: G = (__v_640 * __v_495);
-                let __v_642: G = G::from_u64(4294967296);
-                let __v_643: G = (__v_642 * __v_496);
-                let __v_644: G = G::from_u64(1099511627776);
-                let __v_645: G = (__v_644 * __v_497);
-                let __v_646: G = G::from_u64(281474976710656);
-                let __v_647: G = (__v_646 * __v_498);
-                let __v_648: G = G::from_u64(72057594037927936);
-                let __v_649: G = (__v_648 * __v_499);
-                let __v_650: G = (__v_647 + __v_649);
-                let __v_651: G = (__v_645 + __v_650);
-                let __v_652: G = (__v_643 + __v_651);
-                let __v_653: G = (__v_641 + __v_652);
-                let __v_654: G = (__v_639 + __v_653);
-                let __v_655: G = (__v_637 + __v_654);
-                let __v_656: G = (__v_492 + __v_655);
-                let __v_657: G = G::from_u64(256);
-                let __v_658: G = (__v_657 * __v_501);
-                let __v_659: G = G::from_u64(65536);
-                let __v_660: G = (__v_659 * __v_502);
-                let __v_661: G = G::from_u64(16777216);
-                let __v_662: G = (__v_661 * __v_503);
-                let __v_663: G = G::from_u64(4294967296);
-                let __v_664: G = (__v_663 * __v_504);
-                let __v_665: G = G::from_u64(1099511627776);
-                let __v_666: G = (__v_665 * __v_505);
-                let __v_667: G = G::from_u64(281474976710656);
-                let __v_668: G = (__v_667 * __v_506);
-                let __v_669: G = G::from_u64(72057594037927936);
-                let __v_670: G = (__v_669 * __v_507);
-                let __v_671: G = (__v_668 + __v_670);
-                let __v_672: G = (__v_666 + __v_671);
-                let __v_673: G = (__v_664 + __v_672);
-                let __v_674: G = (__v_662 + __v_673);
-                let __v_675: G = (__v_660 + __v_674);
-                let __v_676: G = (__v_658 + __v_675);
-                let __v_677: G = (__v_500 + __v_676);
-                let __v_678: G = G::from_u64(0);
-                let __v_679: G = G::from_u64(0);
-                let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_678, __v_679, __v_354, __v_530, __v_551, __v_572, __v_593]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } };
-                let __v_680: G = __r_arr[0];
-                let __v_681: G = __r_arr[1];
-                let __v_682: G = G::from_u64(0);
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_357, __v_358, __v_34, __v_30, __v_62, __v_64, __v_59, __v_60, __v_57, __v_682, __v_680, __v_681, __v_530, __v_551, __v_572, __v_593, __v_614, __v_635, __v_656, __v_677]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } };
-                let __v_683: G = __r_arr[0];
-                let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                let __v_684: G = __r_arr[0];
+                let __v_411: G = __mc_out___mc_2[0];
+                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_34, __v_320]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_412: G = __r_arr[0];
+                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_24, __v_412]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_413: G = __r_arr[0];
+                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_411, __v_413]; 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 { let __r = record.function_queries[163].replay_at(__i); record.virt += __r; } 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_414: G = __r_arr[0];
+                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_22, __v_414]; 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 { let __r = record.function_queries[164].replay_at(__i); record.virt += __r; } 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_415: G = __r_arr[0];
+                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_314, __v_415]; 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 { let __r = record.function_queries[173].replay_at(__i); record.virt += __r; } 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_416: G = __r_arr[0];
+                let __v_417: G = G::from_u64(0);
+                let __v_418: G = G::from_u64(109);
+                let __v_419: G = G::from_u64(0);
+                let __v_420: G = G::from_u64(117);
+                let __v_421: G = G::from_u64(0);
+                let __v_422: G = G::from_u64(108);
+                let __v_423: G = G::from_u64(0);
+                let __v_424: G = G::from_u64(116);
+                let __v_425: G = G::from_u64(0);
+                let __v_426: G = G::from_u64(105);
+                let __v_427: G = G::from_u64(0);
+                let __v_428: G = G::from_u64(45);
+                let __v_429: G = G::from_u64(0);
+                let __v_430: G = G::from_u64(115);
+                let __v_431: G = G::from_u64(0);
+                let __v_432: G = G::from_u64(116);
+                let __v_433: G = G::from_u64(0);
+                let __v_434: G = G::from_u64(97);
+                let __v_435: G = G::from_u64(0);
+                let __v_436: G = G::from_u64(114);
+                let __v_437: G = G::from_u64(0);
+                let __v_438: G = G::from_u64(107);
+                let __v_439: G = G::from_u64(0);
+                let __v_440: G = G::from_u64(47);
+                let __v_441: G = G::from_u64(0);
+                let __v_442: G = G::from_u64(118);
+                let __v_443: G = G::from_u64(0);
+                let __v_444: G = G::from_u64(48);
+                let __v_445: G = { let __values: [G; 3] = [__v_443, __v_444, __v_416]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_446: G = { let __values: [G; 3] = [__v_441, __v_442, __v_445]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_447: G = { let __values: [G; 3] = [__v_439, __v_440, __v_446]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_448: G = { let __values: [G; 3] = [__v_437, __v_438, __v_447]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_449: G = { let __values: [G; 3] = [__v_435, __v_436, __v_448]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_450: G = { let __values: [G; 3] = [__v_433, __v_434, __v_449]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_451: G = { let __values: [G; 3] = [__v_431, __v_432, __v_450]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_452: G = { let __values: [G; 3] = [__v_429, __v_430, __v_451]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_453: G = { let __values: [G; 3] = [__v_427, __v_428, __v_452]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_454: G = { let __values: [G; 3] = [__v_425, __v_426, __v_453]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_455: G = { let __values: [G; 3] = [__v_423, __v_424, __v_454]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_456: G = { let __values: [G; 3] = [__v_421, __v_422, __v_455]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_457: G = { let __values: [G; 3] = [__v_419, __v_420, __v_456]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_458: G = { let __values: [G; 3] = [__v_417, __v_418, __v_457]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __v_459: G = G::from_u64(1);
+                let __v_460: G = G::from_u64(1);
+                let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_458, __v_461]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_462: G = __r_arr[0];
+                let __v_463: G = __r_arr[1];
+                let __v_464: G = __r_arr[2];
+                let __v_465: G = __r_arr[3];
+                let __v_466: G = __r_arr[4];
+                let __v_467: G = __r_arr[5];
+                let __v_468: G = __r_arr[6];
+                let __v_469: G = __r_arr[7];
+                let __v_470: G = __r_arr[8];
+                let __v_471: G = __r_arr[9];
+                let __v_472: G = __r_arr[10];
+                let __v_473: G = __r_arr[11];
+                let __v_474: G = __r_arr[12];
+                let __v_475: G = __r_arr[13];
+                let __v_476: G = __r_arr[14];
+                let __v_477: G = __r_arr[15];
+                let __v_478: G = __r_arr[16];
+                let __v_479: G = __r_arr[17];
+                let __v_480: G = G::from_u64(1);
+                let __v_481: G = G::from_u64(1);
+                let __v_482: G = { let __values: [G; 3] = [__v_480, __v_481, __v_481]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_470, __v_471, __v_472, __v_473, __v_474, __v_475, __v_476, __v_477, __v_482]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_483: G = __r_arr[0];
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_462, __v_463, __v_464, __v_465, __v_466, __v_467, __v_468, __v_469, __v_483]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_484: G = __r_arr[0];
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_478, __v_484]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_485: G = __r_arr[0];
+                let __v_486: G = G::from_u64(1);
+                let __v_487: G = G::from_u64(1);
+                let __v_488: G = { let __values: [G; 3] = [__v_486, __v_487, __v_487]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_485, __v_488]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_489: G = __r_arr[0];
+                let __v_490: G = __r_arr[1];
+                let __v_491: G = __r_arr[2];
+                let __v_492: G = __r_arr[3];
+                let __v_493: G = __r_arr[4];
+                let __v_494: G = __r_arr[5];
+                let __v_495: G = __r_arr[6];
+                let __v_496: G = __r_arr[7];
+                let __v_497: G = __r_arr[8];
+                let __v_498: G = __r_arr[9];
+                let __v_499: G = __r_arr[10];
+                let __v_500: G = __r_arr[11];
+                let __v_501: G = __r_arr[12];
+                let __v_502: G = __r_arr[13];
+                let __v_503: G = __r_arr[14];
+                let __v_504: G = __r_arr[15];
+                let __v_505: G = __r_arr[16];
+                let __v_506: G = __r_arr[17];
+                let __v_507: G = G::from_u64(1);
+                let __v_508: G = G::from_u64(1);
+                let __v_509: G = { let __values: [G; 3] = [__v_507, __v_508, __v_508]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_497, __v_498, __v_499, __v_500, __v_501, __v_502, __v_503, __v_504, __v_509]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_510: G = __r_arr[0];
+                let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_489, __v_490, __v_491, __v_492, __v_493, __v_494, __v_495, __v_496, __v_510]; 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 { let __r = record.function_queries[161].replay_at(__i); record.virt += __r; } 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_511: G = __r_arr[0];
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_505, __v_511]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_512: G = __r_arr[0];
+                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_512, __v_26]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_513: G = __r_arr[0];
+                let __v_514: G = G::from_u64(1);
+                let __v_515: G = G::from_u64(1);
+                let __v_516: G = { let __values: [G; 3] = [__v_514, __v_515, __v_515]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_30, __v_516]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_517: G = __r_arr[0];
+                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_513, __v_517]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_518: G = __r_arr[0];
+                let __v_519: G = G::from_u64(1);
+                let __v_520: G = G::from_u64(1);
+                let __v_521: G = { let __values: [G; 3] = [__v_519, __v_520, __v_520]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_518, __v_521]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_522: G = __r_arr[0];
+                let __v_523: G = __r_arr[1];
+                let __v_524: G = __r_arr[2];
+                let __v_525: G = __r_arr[3];
+                let __v_526: G = __r_arr[4];
+                let __v_527: G = __r_arr[5];
+                let __v_528: G = __r_arr[6];
+                let __v_529: G = __r_arr[7];
+                let __v_530: G = __r_arr[8];
+                let __v_531: G = __r_arr[9];
+                let __v_532: G = __r_arr[10];
+                let __v_533: G = __r_arr[11];
+                let __v_534: G = __r_arr[12];
+                let __v_535: G = __r_arr[13];
+                let __v_536: G = __r_arr[14];
+                let __v_537: G = __r_arr[15];
+                let __v_538: G = __r_arr[16];
+                let __v_539: G = __r_arr[17];
+                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_538, __v_28]; 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 { let __r = record.function_queries[171].replay_at(__i); record.virt += __r; } 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_540: G = __r_arr[0];
+                let __v_541: G = G::from_u64(1);
+                let __v_542: G = G::from_u64(1);
+                let __v_543: G = { let __values: [G; 3] = [__v_541, __v_542, __v_542]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_540, __v_543]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_544: G = __r_arr[0];
+                let __v_545: G = __r_arr[1];
+                let __v_546: G = __r_arr[2];
+                let __v_547: G = __r_arr[3];
+                let __v_548: G = __r_arr[4];
+                let __v_549: G = __r_arr[5];
+                let __v_550: G = __r_arr[6];
+                let __v_551: G = __r_arr[7];
+                let __v_552: G = __r_arr[8];
+                let __v_553: G = __r_arr[9];
+                let __v_554: G = __r_arr[10];
+                let __v_555: G = __r_arr[11];
+                let __v_556: G = __r_arr[12];
+                let __v_557: G = __r_arr[13];
+                let __v_558: G = __r_arr[14];
+                let __v_559: G = __r_arr[15];
+                let __v_560: G = __r_arr[16];
+                let __v_561: G = __r_arr[17];
+                let __v_562: G = G::from_u64(256);
+                let __v_563: G = (__v_562 * __v_463);
+                let __v_564: G = G::from_u64(65536);
+                let __v_565: G = (__v_564 * __v_464);
+                let __v_566: G = G::from_u64(16777216);
+                let __v_567: G = (__v_566 * __v_465);
+                let __v_568: G = G::from_u64(4294967296);
+                let __v_569: G = (__v_568 * __v_466);
+                let __v_570: G = G::from_u64(1099511627776);
+                let __v_571: G = (__v_570 * __v_467);
+                let __v_572: G = G::from_u64(281474976710656);
+                let __v_573: G = (__v_572 * __v_468);
+                let __v_574: G = G::from_u64(72057594037927936);
+                let __v_575: G = (__v_574 * __v_469);
+                let __v_576: G = (__v_573 + __v_575);
+                let __v_577: G = (__v_571 + __v_576);
+                let __v_578: G = (__v_569 + __v_577);
+                let __v_579: G = (__v_567 + __v_578);
+                let __v_580: G = (__v_565 + __v_579);
+                let __v_581: G = (__v_563 + __v_580);
+                let __v_582: G = (__v_462 + __v_581);
+                let __v_583: G = G::from_u64(256);
+                let __v_584: G = (__v_583 * __v_471);
+                let __v_585: G = G::from_u64(65536);
+                let __v_586: G = (__v_585 * __v_472);
+                let __v_587: G = G::from_u64(16777216);
+                let __v_588: G = (__v_587 * __v_473);
+                let __v_589: G = G::from_u64(4294967296);
+                let __v_590: G = (__v_589 * __v_474);
+                let __v_591: G = G::from_u64(1099511627776);
+                let __v_592: G = (__v_591 * __v_475);
+                let __v_593: G = G::from_u64(281474976710656);
+                let __v_594: G = (__v_593 * __v_476);
+                let __v_595: G = G::from_u64(72057594037927936);
+                let __v_596: G = (__v_595 * __v_477);
+                let __v_597: G = (__v_594 + __v_596);
+                let __v_598: G = (__v_592 + __v_597);
+                let __v_599: G = (__v_590 + __v_598);
+                let __v_600: G = (__v_588 + __v_599);
+                let __v_601: G = (__v_586 + __v_600);
+                let __v_602: G = (__v_584 + __v_601);
+                let __v_603: G = (__v_470 + __v_602);
+                let __v_604: G = G::from_u64(256);
+                let __v_605: G = (__v_604 * __v_490);
+                let __v_606: G = G::from_u64(65536);
+                let __v_607: G = (__v_606 * __v_491);
+                let __v_608: G = G::from_u64(16777216);
+                let __v_609: G = (__v_608 * __v_492);
+                let __v_610: G = G::from_u64(4294967296);
+                let __v_611: G = (__v_610 * __v_493);
+                let __v_612: G = G::from_u64(1099511627776);
+                let __v_613: G = (__v_612 * __v_494);
+                let __v_614: G = G::from_u64(281474976710656);
+                let __v_615: G = (__v_614 * __v_495);
+                let __v_616: G = G::from_u64(72057594037927936);
+                let __v_617: G = (__v_616 * __v_496);
+                let __v_618: G = (__v_615 + __v_617);
+                let __v_619: G = (__v_613 + __v_618);
+                let __v_620: G = (__v_611 + __v_619);
+                let __v_621: G = (__v_609 + __v_620);
+                let __v_622: G = (__v_607 + __v_621);
+                let __v_623: G = (__v_605 + __v_622);
+                let __v_624: G = (__v_489 + __v_623);
+                let __v_625: G = G::from_u64(256);
+                let __v_626: G = (__v_625 * __v_498);
+                let __v_627: G = G::from_u64(65536);
+                let __v_628: G = (__v_627 * __v_499);
+                let __v_629: G = G::from_u64(16777216);
+                let __v_630: G = (__v_629 * __v_500);
+                let __v_631: G = G::from_u64(4294967296);
+                let __v_632: G = (__v_631 * __v_501);
+                let __v_633: G = G::from_u64(1099511627776);
+                let __v_634: G = (__v_633 * __v_502);
+                let __v_635: G = G::from_u64(281474976710656);
+                let __v_636: G = (__v_635 * __v_503);
+                let __v_637: G = G::from_u64(72057594037927936);
+                let __v_638: G = (__v_637 * __v_504);
+                let __v_639: G = (__v_636 + __v_638);
+                let __v_640: G = (__v_634 + __v_639);
+                let __v_641: G = (__v_632 + __v_640);
+                let __v_642: G = (__v_630 + __v_641);
+                let __v_643: G = (__v_628 + __v_642);
+                let __v_644: G = (__v_626 + __v_643);
+                let __v_645: G = (__v_497 + __v_644);
+                let __v_646: G = G::from_u64(256);
+                let __v_647: G = (__v_646 * __v_523);
+                let __v_648: G = G::from_u64(65536);
+                let __v_649: G = (__v_648 * __v_524);
+                let __v_650: G = G::from_u64(16777216);
+                let __v_651: G = (__v_650 * __v_525);
+                let __v_652: G = G::from_u64(4294967296);
+                let __v_653: G = (__v_652 * __v_526);
+                let __v_654: G = G::from_u64(1099511627776);
+                let __v_655: G = (__v_654 * __v_527);
+                let __v_656: G = G::from_u64(281474976710656);
+                let __v_657: G = (__v_656 * __v_528);
+                let __v_658: G = G::from_u64(72057594037927936);
+                let __v_659: G = (__v_658 * __v_529);
+                let __v_660: G = (__v_657 + __v_659);
+                let __v_661: G = (__v_655 + __v_660);
+                let __v_662: G = (__v_653 + __v_661);
+                let __v_663: G = (__v_651 + __v_662);
+                let __v_664: G = (__v_649 + __v_663);
+                let __v_665: G = (__v_647 + __v_664);
+                let __v_666: G = (__v_522 + __v_665);
+                let __v_667: G = G::from_u64(256);
+                let __v_668: G = (__v_667 * __v_531);
+                let __v_669: G = G::from_u64(65536);
+                let __v_670: G = (__v_669 * __v_532);
+                let __v_671: G = G::from_u64(16777216);
+                let __v_672: G = (__v_671 * __v_533);
+                let __v_673: G = G::from_u64(4294967296);
+                let __v_674: G = (__v_673 * __v_534);
+                let __v_675: G = G::from_u64(1099511627776);
+                let __v_676: G = (__v_675 * __v_535);
+                let __v_677: G = G::from_u64(281474976710656);
+                let __v_678: G = (__v_677 * __v_536);
+                let __v_679: G = G::from_u64(72057594037927936);
+                let __v_680: G = (__v_679 * __v_537);
+                let __v_681: G = (__v_678 + __v_680);
+                let __v_682: G = (__v_676 + __v_681);
+                let __v_683: G = (__v_674 + __v_682);
+                let __v_684: G = (__v_672 + __v_683);
+                let __v_685: G = (__v_670 + __v_684);
+                let __v_686: G = (__v_668 + __v_685);
+                let __v_687: G = (__v_530 + __v_686);
+                let __v_688: G = G::from_u64(256);
+                let __v_689: G = (__v_688 * __v_545);
+                let __v_690: G = G::from_u64(65536);
+                let __v_691: G = (__v_690 * __v_546);
+                let __v_692: G = G::from_u64(16777216);
+                let __v_693: G = (__v_692 * __v_547);
+                let __v_694: G = G::from_u64(4294967296);
+                let __v_695: G = (__v_694 * __v_548);
+                let __v_696: G = G::from_u64(1099511627776);
+                let __v_697: G = (__v_696 * __v_549);
+                let __v_698: G = G::from_u64(281474976710656);
+                let __v_699: G = (__v_698 * __v_550);
+                let __v_700: G = G::from_u64(72057594037927936);
+                let __v_701: G = (__v_700 * __v_551);
+                let __v_702: G = (__v_699 + __v_701);
+                let __v_703: G = (__v_697 + __v_702);
+                let __v_704: G = (__v_695 + __v_703);
+                let __v_705: G = (__v_693 + __v_704);
+                let __v_706: G = (__v_691 + __v_705);
+                let __v_707: G = (__v_689 + __v_706);
+                let __v_708: G = (__v_544 + __v_707);
+                let __v_709: G = G::from_u64(256);
+                let __v_710: G = (__v_709 * __v_553);
+                let __v_711: G = G::from_u64(65536);
+                let __v_712: G = (__v_711 * __v_554);
+                let __v_713: G = G::from_u64(16777216);
+                let __v_714: G = (__v_713 * __v_555);
+                let __v_715: G = G::from_u64(4294967296);
+                let __v_716: G = (__v_715 * __v_556);
+                let __v_717: G = G::from_u64(1099511627776);
+                let __v_718: G = (__v_717 * __v_557);
+                let __v_719: G = G::from_u64(281474976710656);
+                let __v_720: G = (__v_719 * __v_558);
+                let __v_721: G = G::from_u64(72057594037927936);
+                let __v_722: G = (__v_721 * __v_559);
+                let __v_723: G = (__v_720 + __v_722);
+                let __v_724: G = (__v_718 + __v_723);
+                let __v_725: G = (__v_716 + __v_724);
+                let __v_726: G = (__v_714 + __v_725);
+                let __v_727: G = (__v_712 + __v_726);
+                let __v_728: G = (__v_710 + __v_727);
+                let __v_729: G = (__v_552 + __v_728);
+                let __v_730: G = G::from_u64(0);
+                let __v_731: G = G::from_u64(0);
+                let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_730, __v_731, __v_406, __v_582, __v_603, __v_624, __v_645]; 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 { let __r = record.function_queries[197].replay_at(__i); record.virt += __r; } 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_732: G = __r_arr[0];
+                let __v_733: G = __r_arr[1];
+                let __v_734: G = G::from_u64(0);
+                let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_409, __v_410, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_734, __v_732, __v_733, __v_582, __v_603, __v_624, __v_645, __v_666, __v_687, __v_708, __v_729]; 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 { let __r = record.function_queries[195].replay_at(__i); record.virt += __r; } 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_735: G = __r_arr[0];
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_736: G = __r_arr[0];
                 match __v_38.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                    let __v_685: G = __r_arr[0];
-                    let __v_686: G = G::from_u64(1);
-                    let __v_687: G = G::from_u64(1);
-                    let __v_688: G = { let __values: [G; 3] = [__v_686, __v_687, __v_687]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_59.as_canonical_u64() {
+                    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_38]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_737: G = __r_arr[0];
+                    let __v_738: G = G::from_u64(1);
+                    let __v_739: G = G::from_u64(1);
+                    let __v_740: G = { let __values: [G; 3] = [__v_738, __v_739, __v_739]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_63.as_canonical_u64() {
   0u64 => {
-    break '__mc_3 [__v_688];
+    break '__mc_3 [__v_740];
   },
   1u64 => {
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_60, __v_688]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-    let __v_689: G = __r_arr[0];
-    break '__mc_3 [__v_689];
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_64, __v_740]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_741: G = __r_arr[0];
+    break '__mc_3 [__v_741];
   },
   _ => {
-    return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64()));
+    return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64()));
   },
 }
  };
-                    let __v_689: G = __mc_out___mc_3[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_57, __v_689]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_690: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_64, __v_690]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_691: G = __r_arr[0];
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_62, __v_691]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } };
-                    let __v_692: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_508, __v_692]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_693: G = __r_arr[0];
-                    let __v_694: G = G::from_u64(1);
-                    let __v_695: G = G::from_u64(1);
-                    let __v_696: G = { let __values: [G; 3] = [__v_694, __v_695, __v_695]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_693, __v_696]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } };
-                    let __v_697: G = __r_arr[0];
-                    let __v_698: G = __r_arr[1];
-                    let __v_699: G = __r_arr[2];
-                    let __v_700: G = __r_arr[3];
-                    let __v_701: G = __r_arr[4];
-                    let __v_702: G = __r_arr[5];
-                    let __v_703: G = __r_arr[6];
-                    let __v_704: G = __r_arr[7];
-                    let __v_705: G = __r_arr[8];
-                    let __v_706: G = __r_arr[9];
-                    let __v_707: G = __r_arr[10];
-                    let __v_708: G = __r_arr[11];
-                    let __v_709: G = __r_arr[12];
-                    let __v_710: G = __r_arr[13];
-                    let __v_711: G = __r_arr[14];
-                    let __v_712: G = __r_arr[15];
-                    let __v_713: G = __r_arr[16];
-                    let __v_714: G = __r_arr[17];
-                    let __v_715: G = G::from_u64(256);
-                    let __v_716: G = (__v_715 * __v_698);
-                    let __v_717: G = G::from_u64(65536);
-                    let __v_718: G = (__v_717 * __v_699);
-                    let __v_719: G = G::from_u64(16777216);
-                    let __v_720: G = (__v_719 * __v_700);
-                    let __v_721: G = G::from_u64(4294967296);
-                    let __v_722: G = (__v_721 * __v_701);
-                    let __v_723: G = G::from_u64(1099511627776);
-                    let __v_724: G = (__v_723 * __v_702);
-                    let __v_725: G = G::from_u64(281474976710656);
-                    let __v_726: G = (__v_725 * __v_703);
-                    let __v_727: G = G::from_u64(72057594037927936);
-                    let __v_728: G = (__v_727 * __v_704);
-                    let __v_729: G = (__v_726 + __v_728);
-                    let __v_730: G = (__v_724 + __v_729);
-                    let __v_731: G = (__v_722 + __v_730);
-                    let __v_732: G = (__v_720 + __v_731);
-                    let __v_733: G = (__v_718 + __v_732);
-                    let __v_734: G = (__v_716 + __v_733);
-                    let __v_735: G = (__v_697 + __v_734);
-                    let __v_736: G = G::from_u64(256);
-                    let __v_737: G = (__v_736 * __v_706);
-                    let __v_738: G = G::from_u64(65536);
-                    let __v_739: G = (__v_738 * __v_707);
-                    let __v_740: G = G::from_u64(16777216);
-                    let __v_741: G = (__v_740 * __v_708);
-                    let __v_742: G = G::from_u64(4294967296);
-                    let __v_743: G = (__v_742 * __v_709);
-                    let __v_744: G = G::from_u64(1099511627776);
-                    let __v_745: G = (__v_744 * __v_710);
-                    let __v_746: G = G::from_u64(281474976710656);
-                    let __v_747: G = (__v_746 * __v_711);
-                    let __v_748: G = G::from_u64(72057594037927936);
-                    let __v_749: G = (__v_748 * __v_712);
-                    let __v_750: G = (__v_747 + __v_749);
-                    let __v_751: G = (__v_745 + __v_750);
-                    let __v_752: G = (__v_743 + __v_751);
-                    let __v_753: G = (__v_741 + __v_752);
-                    let __v_754: G = (__v_739 + __v_753);
-                    let __v_755: G = (__v_737 + __v_754);
-                    let __v_756: G = (__v_705 + __v_755);
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_713, __v_38, __v_40, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } };
-                    let __v_757: G = __r_arr[0];
-                    let __v_758: G = __r_arr[1];
-                    let __v_759: G = G::from_u64(1);
-                    let __v_760: G = G::from_u64(1);
-                    let __v_761: G = { let __values: [G; 3] = [__v_759, __v_760, __v_760]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[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_46, __v_761]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_116(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } } else { aiur_fn_116(__args, record, io_buffer, __cu)? } };
-                    let __v_762: G = __r_arr[0];
-                    let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_758, __v_762]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
-                    let __v_763: G = __r_arr[0];
-                    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_763, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } };
-                    let __v_764: G = __r_arr[0];
-                    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_764, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } };
-                    let __v_765: G = __r_arr[0];
-                    let __v_766: G = __r_arr[1];
-                    let __v_767: G = (__v_685 + __v_155);
-                    let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } };
-                    let __v_768: G = __r_arr[0];
-                    let __v_769: G = G::from_u64(1);
-                    if (__v_768 != __v_769) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_768.as_canonical_u64(), rhs: __v_769.as_canonical_u64(), msg: None });
+                    let __v_741: G = __mc_out___mc_3[0];
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_61, __v_741]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_742: G = __r_arr[0];
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_68, __v_742]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_743: G = __r_arr[0];
+                    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_66, __v_743]; 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 { let __r = record.function_queries[125].replay_at(__i); record.virt += __r; } 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_744: G = __r_arr[0];
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_560, __v_744]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_745: G = __r_arr[0];
+                    let __v_746: G = G::from_u64(1);
+                    let __v_747: G = G::from_u64(1);
+                    let __v_748: G = { let __values: [G; 3] = [__v_746, __v_747, __v_747]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_745, __v_748]; 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 { let __r = record.function_queries[167].replay_at(__i); record.virt += __r; } 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_749: G = __r_arr[0];
+                    let __v_750: G = __r_arr[1];
+                    let __v_751: G = __r_arr[2];
+                    let __v_752: G = __r_arr[3];
+                    let __v_753: G = __r_arr[4];
+                    let __v_754: G = __r_arr[5];
+                    let __v_755: G = __r_arr[6];
+                    let __v_756: G = __r_arr[7];
+                    let __v_757: G = __r_arr[8];
+                    let __v_758: G = __r_arr[9];
+                    let __v_759: G = __r_arr[10];
+                    let __v_760: G = __r_arr[11];
+                    let __v_761: G = __r_arr[12];
+                    let __v_762: G = __r_arr[13];
+                    let __v_763: G = __r_arr[14];
+                    let __v_764: G = __r_arr[15];
+                    let __v_765: G = __r_arr[16];
+                    let __v_766: G = __r_arr[17];
+                    let __v_767: G = G::from_u64(256);
+                    let __v_768: G = (__v_767 * __v_750);
+                    let __v_769: G = G::from_u64(65536);
+                    let __v_770: G = (__v_769 * __v_751);
+                    let __v_771: G = G::from_u64(16777216);
+                    let __v_772: G = (__v_771 * __v_752);
+                    let __v_773: G = G::from_u64(4294967296);
+                    let __v_774: G = (__v_773 * __v_753);
+                    let __v_775: G = G::from_u64(1099511627776);
+                    let __v_776: G = (__v_775 * __v_754);
+                    let __v_777: G = G::from_u64(281474976710656);
+                    let __v_778: G = (__v_777 * __v_755);
+                    let __v_779: G = G::from_u64(72057594037927936);
+                    let __v_780: G = (__v_779 * __v_756);
+                    let __v_781: G = (__v_778 + __v_780);
+                    let __v_782: G = (__v_776 + __v_781);
+                    let __v_783: G = (__v_774 + __v_782);
+                    let __v_784: G = (__v_772 + __v_783);
+                    let __v_785: G = (__v_770 + __v_784);
+                    let __v_786: G = (__v_768 + __v_785);
+                    let __v_787: G = (__v_749 + __v_786);
+                    let __v_788: G = G::from_u64(256);
+                    let __v_789: G = (__v_788 * __v_758);
+                    let __v_790: G = G::from_u64(65536);
+                    let __v_791: G = (__v_790 * __v_759);
+                    let __v_792: G = G::from_u64(16777216);
+                    let __v_793: G = (__v_792 * __v_760);
+                    let __v_794: G = G::from_u64(4294967296);
+                    let __v_795: G = (__v_794 * __v_761);
+                    let __v_796: G = G::from_u64(1099511627776);
+                    let __v_797: G = (__v_796 * __v_762);
+                    let __v_798: G = G::from_u64(281474976710656);
+                    let __v_799: G = (__v_798 * __v_763);
+                    let __v_800: G = G::from_u64(72057594037927936);
+                    let __v_801: G = (__v_800 * __v_764);
+                    let __v_802: G = (__v_799 + __v_801);
+                    let __v_803: G = (__v_797 + __v_802);
+                    let __v_804: G = (__v_795 + __v_803);
+                    let __v_805: G = (__v_793 + __v_804);
+                    let __v_806: G = (__v_791 + __v_805);
+                    let __v_807: G = (__v_789 + __v_806);
+                    let __v_808: G = (__v_757 + __v_807);
+                    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_765, __v_38, __v_40, __v_209]; 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 { let __r = record.function_queries[129].replay_at(__i); record.virt += __r; } 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_809: G = __r_arr[0];
+                    let __v_810: G = __r_arr[1];
+                    let __v_811: G = G::from_u64(1);
+                    let __v_812: G = G::from_u64(1);
+                    let __v_813: G = { let __values: [G; 3] = [__v_811, __v_812, __v_812]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_50, __v_813]; 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 { let __r = record.function_queries[123].replay_at(__i); record.virt += __r; } 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_814: G = __r_arr[0];
+                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_810, __v_814]; 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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_815: G = __r_arr[0];
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_815, __v_38]; 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 { let __r = record.function_queries[127].replay_at(__i); record.virt += __r; } 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_816: G = __r_arr[0];
+                    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_816, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; 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 { let __r = record.function_queries[128].replay_at(__i); record.virt += __r; } 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_817: G = __r_arr[0];
+                    let __v_818: G = __r_arr[1];
+                    let __v_819: G = (__v_737 + __v_159);
+                    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_817, __v_818, __v_199, __v_819]; 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 { let __r = record.function_queries[150].replay_at(__i); record.virt += __r; } 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_820: G = __r_arr[0];
+                    let __v_821: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_44, __v_48, __v_821, __v_199]; 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 { let __r = record.function_queries[153].replay_at(__i); record.virt += __r; } 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_822: G = __r_arr[0];
+                    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_817, __v_818, __v_822, __v_787, __v_808, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_411, __v_410, __v_34, __v_708, __v_729, __v_736, __v_159, __v_819, __v_809, __v_38, __v_50, __v_737]; 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 { let __r = record.function_queries[149].replay_at(__i); record.virt += __r; } 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_823: G = __r_arr[0];
+                    let __v_824: G = G::from_u64(0);
+                    if (__v_169 != __v_824) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_169.as_canonical_u64(), rhs: __v_824.as_canonical_u64(), msg: None });
+                    }
+                    let __v_825: G = G::from_u64(0);
+                    if (__v_179 != __v_825) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_825.as_canonical_u64(), msg: None });
+                    }
+                    let __v_826: G = G::from_u64(1);
+                    if (__v_189 != __v_826) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_826.as_canonical_u64(), msg: None });
+                    }
+                    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; 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 { let __r = record.function_queries[199].replay_at(__i); record.virt += __r; } 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_827: G = __r_arr[0];
+                    let __v_828: G = G::from_u64(1);
+                    if (__v_827 != __v_828) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_827.as_canonical_u64(), rhs: __v_828.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
-                    let __v_770: G = __r_arr[0];
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_252]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_771: G = __r_arr[0];
-                    let __v_772: G = (__v_770 - __v_771);
-                    let __v_773: G = G::from_bool((__v_772 == G::ZERO));
-                    let __v_774: G = G::from_u64(1);
-                    if (__v_773 != __v_774) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_773.as_canonical_u64(), rhs: __v_774.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_22]; 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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_829: G = __r_arr[0];
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_256]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_830: G = __r_arr[0];
+                    let __v_831: G = (__v_829 - __v_830);
+                    let __v_832: G = G::from_bool((__v_831 == G::ZERO));
+                    let __v_833: G = G::from_u64(1);
+                    if (__v_832 != __v_833) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_832.as_canonical_u64(), rhs: __v_833.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_357]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-                    let __v_775: G = __r_arr[0];
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_776: G = __r_arr[0];
-                    let __v_777: G = (__v_775 - __v_776);
-                    let __v_778: G = G::from_bool((__v_777 == G::ZERO));
-                    let __v_779: G = G::from_u64(1);
-                    if (__v_778 != __v_779) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_778.as_canonical_u64(), rhs: __v_779.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_409]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_834: G = __r_arr[0];
+                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_30]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_835: G = __r_arr[0];
+                    let __v_836: G = (__v_834 - __v_835);
+                    let __v_837: G = G::from_bool((__v_836 == G::ZERO));
+                    let __v_838: G = G::from_u64(1);
+                    if (__v_837 != __v_838) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_837.as_canonical_u64(), rhs: __v_838.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-                    let __v_780: G = __r_arr[0];
-                    let __v_781: G = (__v_780 - __v_685);
-                    let __v_782: G = G::from_bool((__v_781 == G::ZERO));
-                    let __v_783: G = G::from_u64(1);
-                    if (__v_782 != __v_783) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_782.as_canonical_u64(), rhs: __v_783.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_40]; 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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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_839: G = __r_arr[0];
+                    let __v_840: G = (__v_839 - __v_737);
+                    let __v_841: G = G::from_bool((__v_840 == G::ZERO));
+                    let __v_842: G = G::from_u64(1);
+                    if (__v_841 != __v_842) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_841.as_canonical_u64(), rhs: __v_842.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_784: G = __r_arr[0];
-                    let __v_785: G = (__v_784 - __v_195);
-                    let __v_786: G = G::from_bool((__v_785 == G::ZERO));
-                    let __v_787: G = G::from_u64(1);
-                    if (__v_786 != __v_787) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_786.as_canonical_u64(), rhs: __v_787.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_843: G = __r_arr[0];
+                    let __v_844: G = G::from_u64(3);
+                    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_63, __v_64]; 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 { let __r = record.function_queries[134].replay_at(__i); record.virt += __r; } 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_845: G = __r_arr[0];
+                    let __v_846: G = (__v_844 + __v_845);
+                    if (__v_843 != __v_846) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_843.as_canonical_u64(), rhs: __v_846.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-                    let __v_788: G = __r_arr[0];
-                    let __v_789: G = G::from_u64(1);
-                    if (__v_788 != __v_789) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_788.as_canonical_u64(), rhs: __v_789.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_48]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_847: G = __r_arr[0];
+                    let __v_848: G = (__v_847 - __v_737);
+                    let __v_849: G = G::from_bool((__v_848 == G::ZERO));
+                    let __v_850: G = G::from_u64(1);
+                    if (__v_849 != __v_850) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_849.as_canonical_u64(), rhs: __v_850.as_canonical_u64(), msg: None });
                     }
-                    let __v_790: G = G::from_u64(33);
-                    let __v_791: G = { let __a_val = __v_767.as_canonical_u64(); let __b_val = __v_790.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-                    let __v_792: G = G::from_u64(1);
-                    if (__v_791 != __v_792) {
-                      return Err(ExecError::AssertEqMismatch { lhs: __v_791.as_canonical_u64(), rhs: __v_792.as_canonical_u64(), msg: None });
+                    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_50]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_851: G = __r_arr[0];
+                    let __v_852: G = G::from_u64(1);
+                    if (__v_851 != __v_852) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_851.as_canonical_u64(), rhs: __v_852.as_canonical_u64(), msg: None });
                     }
-                    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_765, __v_766, __v_44, __v_735, __v_756, __v_62, __v_64, __v_57, __v_59, __v_60, __v_24, __v_26, __v_28, __v_359, __v_358, __v_34, __v_656, __v_677, __v_684, __v_155, __v_767, __v_757, __v_38, __v_46, __v_685]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_142(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } } else { aiur_fn_142(__args, record, io_buffer, __cu)? } };
-                    let __v_793: G = __r_arr[0];
-                    break '__mc_1 [__v_793];
+                    let __v_853: G = G::from_u64(33);
+                    let __v_854: G = { let __a_val = __v_819.as_canonical_u64(); let __b_val = __v_853.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
+                    let __v_855: G = G::from_u64(1);
+                    if (__v_854 != __v_855) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_854.as_canonical_u64(), rhs: __v_855.as_canonical_u64(), msg: None });
+                    }
+                    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_820, __v_24, __v_26, __v_28, __v_411, __v_63, __v_64, __v_410, __v_34, __v_736, __v_159, __v_819]; 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 { let __r = record.function_queries[154].replay_at(__i); record.virt += __r; } 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_856: G = __r_arr[0];
+                    let __v_857: G = G::from_u64(1);
+                    if (__v_856 != __v_857) {
+                      return Err(ExecError::AssertEqMismatch { lhs: __v_856.as_canonical_u64(), rhs: __v_857.as_canonical_u64(), msg: None });
+                    }
+                    let __v_858: G = G::from_u64(0);
+                    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_48, __v_38, __v_823, __v_820, __v_858, __v_819]; 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 { let __r = record.function_queries[157].replay_at(__i); record.virt += __r; } 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_859: G = __r_arr[0];
+                    break '__mc_1 [__v_859];
                   },
                 }
               },
@@ -19184,269 +26628,270 @@ fn aiur_fn_191(
   },
 }
  };
-    let __v_357: G = __mc_out___mc_1[0];
-    let __v_358: G = (__v_18 + __v_19);
-    if (__v_65 != __v_358) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_358.as_canonical_u64(), msg: None });
-    }
-    let __v_359: G = G::from_u64(256);
-    let __v_360: G = (__v_359 * __v_124);
-    let __v_361: G = G::from_u64(65536);
-    let __v_362: G = (__v_361 * __v_125);
-    let __v_363: G = G::from_u64(16777216);
-    let __v_364: G = (__v_363 * __v_126);
-    let __v_365: G = (__v_362 + __v_364);
-    let __v_366: G = (__v_360 + __v_365);
-    let __v_367: G = (__v_123 + __v_366);
-    let __v_368: G = G::from_u64(256);
-    let __v_369: G = (__v_368 * __v_128);
-    let __v_370: G = G::from_u64(65536);
-    let __v_371: G = (__v_370 * __v_129);
-    let __v_372: G = G::from_u64(16777216);
-    let __v_373: G = (__v_372 * __v_130);
-    let __v_374: G = (__v_371 + __v_373);
-    let __v_375: G = (__v_369 + __v_374);
-    let __v_376: G = (__v_127 + __v_375);
-    let __v_377: G = G::from_u64(256);
-    let __v_378: G = (__v_377 * __v_132);
-    let __v_379: G = G::from_u64(65536);
-    let __v_380: G = (__v_379 * __v_133);
-    let __v_381: G = G::from_u64(16777216);
-    let __v_382: G = (__v_381 * __v_134);
-    let __v_383: G = (__v_380 + __v_382);
-    let __v_384: G = (__v_378 + __v_383);
-    let __v_385: G = (__v_131 + __v_384);
-    let __v_386: G = G::from_u64(256);
-    let __v_387: G = (__v_386 * __v_136);
-    let __v_388: G = G::from_u64(65536);
-    let __v_389: G = (__v_388 * __v_137);
-    let __v_390: G = G::from_u64(16777216);
-    let __v_391: G = (__v_390 * __v_138);
-    let __v_392: G = (__v_389 + __v_391);
-    let __v_393: G = (__v_387 + __v_392);
-    let __v_394: G = (__v_135 + __v_393);
-    let __v_395: G = G::from_u64(256);
-    let __v_396: G = (__v_395 * __v_140);
-    let __v_397: G = G::from_u64(65536);
-    let __v_398: G = (__v_397 * __v_141);
-    let __v_399: G = G::from_u64(16777216);
-    let __v_400: G = (__v_399 * __v_142);
-    let __v_401: G = (__v_398 + __v_400);
-    let __v_402: G = (__v_396 + __v_401);
-    let __v_403: G = (__v_139 + __v_402);
-    let __v_404: G = G::from_u64(256);
-    let __v_405: G = (__v_404 * __v_144);
-    let __v_406: G = G::from_u64(65536);
-    let __v_407: G = (__v_406 * __v_145);
-    let __v_408: G = G::from_u64(16777216);
-    let __v_409: G = (__v_408 * __v_146);
-    let __v_410: G = (__v_407 + __v_409);
-    let __v_411: G = (__v_405 + __v_410);
-    let __v_412: G = (__v_143 + __v_411);
-    let __v_413: G = G::from_u64(256);
-    let __v_414: G = (__v_413 * __v_148);
-    let __v_415: G = G::from_u64(65536);
-    let __v_416: G = (__v_415 * __v_149);
-    let __v_417: G = G::from_u64(16777216);
-    let __v_418: G = (__v_417 * __v_150);
-    let __v_419: G = (__v_416 + __v_418);
-    let __v_420: G = (__v_414 + __v_419);
-    let __v_421: G = (__v_147 + __v_420);
-    let __v_422: G = G::from_u64(256);
-    let __v_423: G = (__v_422 * __v_152);
-    let __v_424: G = G::from_u64(65536);
-    let __v_425: G = (__v_424 * __v_153);
-    let __v_426: G = G::from_u64(16777216);
-    let __v_427: G = (__v_426 * __v_154);
-    let __v_428: G = (__v_425 + __v_427);
-    let __v_429: G = (__v_423 + __v_428);
-    let __v_430: G = (__v_151 + __v_429);
-    if (__v_367 != __v_0) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_367.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
-    }
-    if (__v_376 != __v_1) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
-    }
-    if (__v_385 != __v_2) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_385.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
-    }
-    if (__v_394 != __v_3) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
-    }
-    if (__v_403 != __v_4) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_403.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
-    }
-    if (__v_412 != __v_5) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_412.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
-    }
-    if (__v_421 != __v_6) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
-    }
-    if (__v_430 != __v_7) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_430.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
-    }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_259.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_431: G = __loaded[0];
-    let __v_432: G = __loaded[1];
-    let __v_433: G = __loaded[2];
-    let __v_434: G = G::from_u64(1);
-    let __v_435: G = G::from_u64(1);
-    if (__v_431 != __v_434) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_431.as_canonical_u64(), rhs: __v_434.as_canonical_u64(), msg: None });
-    }
-    if (__v_432 != __v_435) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_432.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None });
-    }
-    if (__v_433 != __v_435) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_433.as_canonical_u64(), rhs: __v_435.as_canonical_u64(), msg: None });
-    }
-    let __v_436: G = G::from_u64(256);
-    let __v_437: G = (__v_436 * __v_321);
-    let __v_438: G = G::from_u64(65536);
-    let __v_439: G = (__v_438 * __v_322);
-    let __v_440: G = G::from_u64(16777216);
-    let __v_441: G = (__v_440 * __v_323);
-    let __v_442: G = (__v_439 + __v_441);
-    let __v_443: G = (__v_437 + __v_442);
-    let __v_444: G = (__v_320 + __v_443);
-    let __v_445: G = G::from_u64(256);
-    let __v_446: G = (__v_445 * __v_325);
-    let __v_447: G = G::from_u64(65536);
-    let __v_448: G = (__v_447 * __v_326);
-    let __v_449: G = G::from_u64(16777216);
-    let __v_450: G = (__v_449 * __v_327);
-    let __v_451: G = (__v_448 + __v_450);
-    let __v_452: G = (__v_446 + __v_451);
-    let __v_453: G = (__v_324 + __v_452);
-    let __v_454: G = G::from_u64(256);
-    let __v_455: G = (__v_454 * __v_329);
-    let __v_456: G = G::from_u64(65536);
-    let __v_457: G = (__v_456 * __v_330);
-    let __v_458: G = G::from_u64(16777216);
-    let __v_459: G = (__v_458 * __v_331);
-    let __v_460: G = (__v_457 + __v_459);
-    let __v_461: G = (__v_455 + __v_460);
-    let __v_462: G = (__v_328 + __v_461);
-    let __v_463: G = G::from_u64(256);
-    let __v_464: G = (__v_463 * __v_333);
-    let __v_465: G = G::from_u64(65536);
-    let __v_466: G = (__v_465 * __v_334);
-    let __v_467: G = G::from_u64(16777216);
-    let __v_468: G = (__v_467 * __v_335);
-    let __v_469: G = (__v_466 + __v_468);
-    let __v_470: G = (__v_464 + __v_469);
-    let __v_471: G = (__v_332 + __v_470);
-    let __v_472: G = G::from_u64(256);
-    let __v_473: G = (__v_472 * __v_337);
-    let __v_474: G = G::from_u64(65536);
-    let __v_475: G = (__v_474 * __v_338);
-    let __v_476: G = G::from_u64(16777216);
-    let __v_477: G = (__v_476 * __v_339);
-    let __v_478: G = (__v_475 + __v_477);
-    let __v_479: G = (__v_473 + __v_478);
-    let __v_480: G = (__v_336 + __v_479);
-    let __v_481: G = G::from_u64(256);
-    let __v_482: G = (__v_481 * __v_341);
-    let __v_483: G = G::from_u64(65536);
-    let __v_484: G = (__v_483 * __v_342);
-    let __v_485: G = G::from_u64(16777216);
-    let __v_486: G = (__v_485 * __v_343);
-    let __v_487: G = (__v_484 + __v_486);
-    let __v_488: G = (__v_482 + __v_487);
-    let __v_489: G = (__v_340 + __v_488);
-    let __v_490: G = G::from_u64(256);
-    let __v_491: G = (__v_490 * __v_345);
-    let __v_492: G = G::from_u64(65536);
-    let __v_493: G = (__v_492 * __v_346);
-    let __v_494: G = G::from_u64(16777216);
-    let __v_495: G = (__v_494 * __v_347);
-    let __v_496: G = (__v_493 + __v_495);
-    let __v_497: G = (__v_491 + __v_496);
-    let __v_498: G = (__v_344 + __v_497);
-    let __v_499: G = G::from_u64(256);
-    let __v_500: G = (__v_499 * __v_349);
-    let __v_501: G = G::from_u64(65536);
-    let __v_502: G = (__v_501 * __v_350);
-    let __v_503: G = G::from_u64(16777216);
-    let __v_504: G = (__v_503 * __v_351);
-    let __v_505: G = (__v_502 + __v_504);
-    let __v_506: G = (__v_500 + __v_505);
-    let __v_507: G = (__v_348 + __v_506);
-    if (__v_444 != __v_8) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
-    }
-    if (__v_453 != __v_9) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_453.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
-    }
-    if (__v_462 != __v_10) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_462.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
-    }
-    if (__v_471 != __v_11) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_471.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
-    }
-    if (__v_480 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
-    }
-    if (__v_489 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
-    }
-    if (__v_498 != __v_14) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_498.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
-    }
-    if (__v_507 != __v_15) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_507.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
-    }
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_355.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_508: G = __loaded[0];
-    let __v_509: G = __loaded[1];
-    let __v_510: G = __loaded[2];
-    let __v_511: G = G::from_u64(1);
-    let __v_512: G = G::from_u64(1);
-    if (__v_508 != __v_511) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_508.as_canonical_u64(), rhs: __v_511.as_canonical_u64(), msg: None });
-    }
-    if (__v_509 != __v_512) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None });
-    }
-    if (__v_510 != __v_512) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_510.as_canonical_u64(), rhs: __v_512.as_canonical_u64(), msg: None });
-    }
-    let __v_513: G = G::from_u64(1);
-    if (__v_356 != __v_513) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: None });
-    }
-    let __v_514: G = G::from_u64(1);
-    if (__v_357 != __v_514) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_357.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: None });
-    }
-    let __ret: [G; OUT_191] = [];
-    if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+    let __v_409: G = __mc_out___mc_1[0];
+    let __v_410: G = (__v_18 + __v_19);
+    if (__v_69 != __v_410) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_410.as_canonical_u64(), msg: None });
+    }
+    let __v_411: G = G::from_u64(256);
+    let __v_412: G = (__v_411 * __v_128);
+    let __v_413: G = G::from_u64(65536);
+    let __v_414: G = (__v_413 * __v_129);
+    let __v_415: G = G::from_u64(16777216);
+    let __v_416: G = (__v_415 * __v_130);
+    let __v_417: G = (__v_414 + __v_416);
+    let __v_418: G = (__v_412 + __v_417);
+    let __v_419: G = (__v_127 + __v_418);
+    let __v_420: G = G::from_u64(256);
+    let __v_421: G = (__v_420 * __v_132);
+    let __v_422: G = G::from_u64(65536);
+    let __v_423: G = (__v_422 * __v_133);
+    let __v_424: G = G::from_u64(16777216);
+    let __v_425: G = (__v_424 * __v_134);
+    let __v_426: G = (__v_423 + __v_425);
+    let __v_427: G = (__v_421 + __v_426);
+    let __v_428: G = (__v_131 + __v_427);
+    let __v_429: G = G::from_u64(256);
+    let __v_430: G = (__v_429 * __v_136);
+    let __v_431: G = G::from_u64(65536);
+    let __v_432: G = (__v_431 * __v_137);
+    let __v_433: G = G::from_u64(16777216);
+    let __v_434: G = (__v_433 * __v_138);
+    let __v_435: G = (__v_432 + __v_434);
+    let __v_436: G = (__v_430 + __v_435);
+    let __v_437: G = (__v_135 + __v_436);
+    let __v_438: G = G::from_u64(256);
+    let __v_439: G = (__v_438 * __v_140);
+    let __v_440: G = G::from_u64(65536);
+    let __v_441: G = (__v_440 * __v_141);
+    let __v_442: G = G::from_u64(16777216);
+    let __v_443: G = (__v_442 * __v_142);
+    let __v_444: G = (__v_441 + __v_443);
+    let __v_445: G = (__v_439 + __v_444);
+    let __v_446: G = (__v_139 + __v_445);
+    let __v_447: G = G::from_u64(256);
+    let __v_448: G = (__v_447 * __v_144);
+    let __v_449: G = G::from_u64(65536);
+    let __v_450: G = (__v_449 * __v_145);
+    let __v_451: G = G::from_u64(16777216);
+    let __v_452: G = (__v_451 * __v_146);
+    let __v_453: G = (__v_450 + __v_452);
+    let __v_454: G = (__v_448 + __v_453);
+    let __v_455: G = (__v_143 + __v_454);
+    let __v_456: G = G::from_u64(256);
+    let __v_457: G = (__v_456 * __v_148);
+    let __v_458: G = G::from_u64(65536);
+    let __v_459: G = (__v_458 * __v_149);
+    let __v_460: G = G::from_u64(16777216);
+    let __v_461: G = (__v_460 * __v_150);
+    let __v_462: G = (__v_459 + __v_461);
+    let __v_463: G = (__v_457 + __v_462);
+    let __v_464: G = (__v_147 + __v_463);
+    let __v_465: G = G::from_u64(256);
+    let __v_466: G = (__v_465 * __v_152);
+    let __v_467: G = G::from_u64(65536);
+    let __v_468: G = (__v_467 * __v_153);
+    let __v_469: G = G::from_u64(16777216);
+    let __v_470: G = (__v_469 * __v_154);
+    let __v_471: G = (__v_468 + __v_470);
+    let __v_472: G = (__v_466 + __v_471);
+    let __v_473: G = (__v_151 + __v_472);
+    let __v_474: G = G::from_u64(256);
+    let __v_475: G = (__v_474 * __v_156);
+    let __v_476: G = G::from_u64(65536);
+    let __v_477: G = (__v_476 * __v_157);
+    let __v_478: G = G::from_u64(16777216);
+    let __v_479: G = (__v_478 * __v_158);
+    let __v_480: G = (__v_477 + __v_479);
+    let __v_481: G = (__v_475 + __v_480);
+    let __v_482: G = (__v_155 + __v_481);
+    if (__v_419 != __v_0) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_419.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: None });
+    }
+    if (__v_428 != __v_1) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_428.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: None });
+    }
+    if (__v_437 != __v_2) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_437.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: None });
+    }
+    if (__v_446 != __v_3) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_446.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: None });
+    }
+    if (__v_455 != __v_4) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: None });
+    }
+    if (__v_464 != __v_5) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_464.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: None });
+    }
+    if (__v_473 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_473.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: None });
+    }
+    if (__v_482 != __v_7) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_482.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_483: G = __loaded[0];
+    let __v_484: G = __loaded[1];
+    let __v_485: G = __loaded[2];
+    let __v_486: G = G::from_u64(1);
+    let __v_487: G = G::from_u64(1);
+    if (__v_483 != __v_486) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None });
+    }
+    if (__v_484 != __v_487) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_484.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None });
+    }
+    if (__v_485 != __v_487) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_487.as_canonical_u64(), msg: None });
+    }
+    let __v_488: G = G::from_u64(256);
+    let __v_489: G = (__v_488 * __v_373);
+    let __v_490: G = G::from_u64(65536);
+    let __v_491: G = (__v_490 * __v_374);
+    let __v_492: G = G::from_u64(16777216);
+    let __v_493: G = (__v_492 * __v_375);
+    let __v_494: G = (__v_491 + __v_493);
+    let __v_495: G = (__v_489 + __v_494);
+    let __v_496: G = (__v_372 + __v_495);
+    let __v_497: G = G::from_u64(256);
+    let __v_498: G = (__v_497 * __v_377);
+    let __v_499: G = G::from_u64(65536);
+    let __v_500: G = (__v_499 * __v_378);
+    let __v_501: G = G::from_u64(16777216);
+    let __v_502: G = (__v_501 * __v_379);
+    let __v_503: G = (__v_500 + __v_502);
+    let __v_504: G = (__v_498 + __v_503);
+    let __v_505: G = (__v_376 + __v_504);
+    let __v_506: G = G::from_u64(256);
+    let __v_507: G = (__v_506 * __v_381);
+    let __v_508: G = G::from_u64(65536);
+    let __v_509: G = (__v_508 * __v_382);
+    let __v_510: G = G::from_u64(16777216);
+    let __v_511: G = (__v_510 * __v_383);
+    let __v_512: G = (__v_509 + __v_511);
+    let __v_513: G = (__v_507 + __v_512);
+    let __v_514: G = (__v_380 + __v_513);
+    let __v_515: G = G::from_u64(256);
+    let __v_516: G = (__v_515 * __v_385);
+    let __v_517: G = G::from_u64(65536);
+    let __v_518: G = (__v_517 * __v_386);
+    let __v_519: G = G::from_u64(16777216);
+    let __v_520: G = (__v_519 * __v_387);
+    let __v_521: G = (__v_518 + __v_520);
+    let __v_522: G = (__v_516 + __v_521);
+    let __v_523: G = (__v_384 + __v_522);
+    let __v_524: G = G::from_u64(256);
+    let __v_525: G = (__v_524 * __v_389);
+    let __v_526: G = G::from_u64(65536);
+    let __v_527: G = (__v_526 * __v_390);
+    let __v_528: G = G::from_u64(16777216);
+    let __v_529: G = (__v_528 * __v_391);
+    let __v_530: G = (__v_527 + __v_529);
+    let __v_531: G = (__v_525 + __v_530);
+    let __v_532: G = (__v_388 + __v_531);
+    let __v_533: G = G::from_u64(256);
+    let __v_534: G = (__v_533 * __v_393);
+    let __v_535: G = G::from_u64(65536);
+    let __v_536: G = (__v_535 * __v_394);
+    let __v_537: G = G::from_u64(16777216);
+    let __v_538: G = (__v_537 * __v_395);
+    let __v_539: G = (__v_536 + __v_538);
+    let __v_540: G = (__v_534 + __v_539);
+    let __v_541: G = (__v_392 + __v_540);
+    let __v_542: G = G::from_u64(256);
+    let __v_543: G = (__v_542 * __v_397);
+    let __v_544: G = G::from_u64(65536);
+    let __v_545: G = (__v_544 * __v_398);
+    let __v_546: G = G::from_u64(16777216);
+    let __v_547: G = (__v_546 * __v_399);
+    let __v_548: G = (__v_545 + __v_547);
+    let __v_549: G = (__v_543 + __v_548);
+    let __v_550: G = (__v_396 + __v_549);
+    let __v_551: G = G::from_u64(256);
+    let __v_552: G = (__v_551 * __v_401);
+    let __v_553: G = G::from_u64(65536);
+    let __v_554: G = (__v_553 * __v_402);
+    let __v_555: G = G::from_u64(16777216);
+    let __v_556: G = (__v_555 * __v_403);
+    let __v_557: G = (__v_554 + __v_556);
+    let __v_558: G = (__v_552 + __v_557);
+    let __v_559: G = (__v_400 + __v_558);
+    if (__v_496 != __v_8) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_496.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None });
+    }
+    if (__v_505 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_505.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: None });
+    }
+    if (__v_514 != __v_10) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: None });
+    }
+    if (__v_523 != __v_11) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None });
+    }
+    if (__v_532 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_532.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: None });
+    }
+    if (__v_541 != __v_13) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: None });
+    }
+    if (__v_550 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_550.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: None });
+    }
+    if (__v_559 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_559.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None });
+    }
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_407.as_canonical_u64(); let __ptr_usize = usize::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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_560: G = __loaded[0];
+    let __v_561: G = __loaded[1];
+    let __v_562: G = __loaded[2];
+    let __v_563: G = G::from_u64(1);
+    let __v_564: G = G::from_u64(1);
+    if (__v_560 != __v_563) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_560.as_canonical_u64(), rhs: __v_563.as_canonical_u64(), msg: None });
+    }
+    if (__v_561 != __v_564) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_561.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None });
+    }
+    if (__v_562 != __v_564) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_562.as_canonical_u64(), rhs: __v_564.as_canonical_u64(), msg: None });
+    }
+    let __v_565: G = G::from_u64(1);
+    if (__v_408 != __v_565) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_408.as_canonical_u64(), rhs: __v_565.as_canonical_u64(), msg: None });
+    }
+    let __v_566: G = G::from_u64(1);
+    if (__v_409 != __v_566) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_409.as_canonical_u64(), rhs: __v_566.as_canonical_u64(), msg: None });
+    }
+    let __ret: [G; OUT_241] = [];
+    if !unconstrained { record.virt += record.function_queries[241].weight(); } record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 2;
-const IN_192: usize = 2;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_242: usize = 2;
+const IN_242: usize = 2;
+const OUT_242: usize = 1;
+fn aiur_fn_242(
+  inp: [G; IN_242],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_242], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_1]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_192] = [__v_4];
-        if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_242] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[242].weight(); } record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19456,32 +26901,36 @@ fn aiur_fn_192(
   })
 }
 
-const INPUT_SIZE_193: usize = 1;
-const IN_193: usize = 1;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_243: usize = 1;
+const IN_243: usize = 1;
+const OUT_243: usize = 1;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
       1u64 => {
-        let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_243] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_193] = [__v_4];
-        if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        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 { let __r = record.function_queries[243].replay_at(__i); record.virt += __r; } 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_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_243] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[243].weight(); } record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19491,69 +26940,118 @@ fn aiur_fn_193(
   })
 }
 
-const INPUT_SIZE_194: usize = 2;
-const IN_194: usize = 2;
-const OUT_194: usize = 2;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_244: usize = 1;
+const IN_244: usize = 1;
+const OUT_244: usize = 1;
+fn aiur_fn_244(
+  inp: [G; IN_244],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_244], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_5: G = G::from_u64(0);
+        let __ret: [G; OUT_244] = [__v_5];
+        if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; 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 { let __r = record.function_queries[244].replay_at(__i); record.virt += __r; } 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_5: G = __r_arr[0];
+        let __v_6: G = G::from_u64(1);
+        let __v_7: G = (__v_5 + __v_6);
+        let __ret: [G; OUT_244] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[244].weight(); } record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
-    let __v_2: G = __r_arr[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
-    let __v_3: G = __loaded[0];
-    let __v_4: G = __loaded[1];
-    let __v_5: G = __loaded[2];
-    let __v_6: G = __loaded[3];
-    match __v_3.as_canonical_u64() {
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_2: G = __loaded[0];
+    let __v_3: G = __loaded[1];
+    let __v_4: G = __loaded[2];
+    match __v_2.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_245] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
       0u64 => {
-        let __ret: [G; OUT_194] = [__v_4, __v_5];
-        if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_5: G = G::from_u64(0);
+        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4, __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 { let __r = record.function_queries[245].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_245] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[245].weight(); } record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_195: usize = 1;
-const IN_195: usize = 1;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+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_195], ExecError> {
+) -> Result<[G; OUT_246], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
     let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_195] = [__v_6];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_7: G = G::from_u64(0);
+        let __ret: [G; OUT_246] = [__v_7];
+        if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } };
-        let __v_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_195] = [__v_8];
-        if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_6]; 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 { let __r = record.function_queries[246].replay_at(__i); record.virt += __r; } 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 __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_246] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[246].weight(); } record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19563,36 +27061,40 @@ fn aiur_fn_195(
   })
 }
 
-const INPUT_SIZE_196: usize = 1;
-const IN_196: usize = 1;
-const OUT_196: usize = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_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_196], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
     let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_196] = [__v_5];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_8: G = G::from_u64(0);
+        let __ret: [G; OUT_247] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } };
-        let __v_5: G = __r_arr[0];
-        let __v_6: G = G::from_u64(1);
-        let __v_7: G = (__v_5 + __v_6);
-        let __ret: [G; OUT_196] = [__v_7];
-        if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__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 { let __r = record.function_queries[247].replay_at(__i); record.virt += __r; } 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];
+        let __v_9: G = G::from_u64(1);
+        let __v_10: G = (__v_8 + __v_9);
+        let __ret: [G; OUT_247] = [__v_10];
+        if !unconstrained { record.virt += record.function_queries[247].weight(); } record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19602,19 +27104,170 @@ fn aiur_fn_196(
   })
 }
 
-const INPUT_SIZE_197: usize = 2;
-const IN_197: usize = 2;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_248: usize = 1;
+const IN_248: usize = 1;
+const OUT_248: usize = 1;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_248], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    let __v_6: G = __loaded[5];
+    let __v_7: G = __loaded[6];
+    let __v_8: G = __loaded[7];
+    let __v_9: G = __loaded[8];
+    let __v_10: G = __loaded[9];
+    match __v_1.as_canonical_u64() {
+      1u64 => {
+        let __v_11: G = G::from_u64(0);
+        let __ret: [G; OUT_248] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        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 { let __r = record.function_queries[248].replay_at(__i); record.virt += __r; } 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 = G::from_u64(1);
+        let __v_13: G = (__v_11 + __v_12);
+        let __ret: [G; OUT_248] = [__v_13];
+        if !unconstrained { record.virt += record.function_queries[248].weight(); } record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_249: usize = 2;
+const IN_249: usize = 2;
+const OUT_249: usize = 4;
+fn aiur_fn_249(
+  inp: [G; IN_249],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_249], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; 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 { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
+    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __v_3: G = __loaded[0];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    let __v_7: G = __loaded[4];
+    let __v_8: G = __loaded[5];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_249] = [__v_4, __v_5, __v_6, __v_7];
+        if !unconstrained { record.virt += record.function_queries[249].weight(); } record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_250], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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() {
+      1u64 => {
+        let __v_4: G = G::from_u64(1);
+        let __ret: [G; OUT_250] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __v_4: G = G::from_u64(0);
+        let __ret: [G; OUT_250] = [__v_4];
+        if !unconstrained { record.virt += record.function_queries[250].weight(); } record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_251: usize = 2;
+const IN_251: usize = 2;
+const OUT_251: usize = 2;
+fn aiur_fn_251(
+  inp: [G; IN_251],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_251], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; 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 { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } 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_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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
+    let __v_4: G = __loaded[1];
+    let __v_5: G = __loaded[2];
+    let __v_6: G = __loaded[3];
+    match __v_3.as_canonical_u64() {
+      0u64 => {
+        let __ret: [G; OUT_251] = [__v_4, __v_5];
+        if !unconstrained { record.virt += record.function_queries[251].weight(); } record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+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_252], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_3: G = __loaded[1];
     let __v_4: G = __loaded[2];
@@ -19627,17 +27280,17 @@ fn aiur_fn_197(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_197] = [__v_1];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_252] = [__v_1];
+        if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
         let __v_12: G = G::from_u64(0);
-        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_11, __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 { let __r = record.function_queries[252].replay_at(__i); record.virt += __r; } 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_13: G = __r_arr[0];
-        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_197] = [__v_14];
-        if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { let __r = __mq.replay_at(__i); record.virt += __r; } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); if !unconstrained { record.virt += __mq.weight(); } __ptr } };
+        let __ret: [G; OUT_252] = [__v_14];
+        if !unconstrained { record.virt += record.function_queries[252].weight(); } record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19647,75 +27300,79 @@ fn aiur_fn_197(
   })
 }
 
-const INPUT_SIZE_198: usize = 2;
-const IN_198: usize = 2;
-const OUT_198: usize = 1;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_253: usize = 1;
+const IN_253: usize = 1;
+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_198], 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];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_2: G = __loaded[0];
-    let __v_3: G = __loaded[1];
-    let __v_4: G = __loaded[2];
-    match __v_2.as_canonical_u64() {
+  let __vsnap = record.virt;
+    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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
+    let __v_1: G = __loaded[0];
+    let __v_2: G = __loaded[1];
+    let __v_3: G = __loaded[2];
+    let __v_4: G = __loaded[3];
+    let __v_5: G = __loaded[4];
+    match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_198] = [__v_1];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_6: G = G::from_u64(0);
+        let __ret: [G; OUT_253] = [__v_6];
+        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5]; 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 { let __r = record.function_queries[253].replay_at(__i); record.virt += __r; } 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_6: G = __r_arr[0];
-        let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_7];
-        if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_7: G = G::from_u64(1);
+        let __v_8: G = (__v_6 + __v_7);
+        let __ret: [G; OUT_253] = [__v_8];
+        if !unconstrained { record.virt += record.function_queries[253].weight(); } record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
       },
     }
   })
 }
 
-const INPUT_SIZE_199: usize = 2;
-const IN_199: usize = 2;
-const OUT_199: usize = 1;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_254: usize = 2;
+const IN_254: usize = 2;
+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_199], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_199] = [__v_0];
-        if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_254] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3]; 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 { let __r = record.function_queries[254].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_199] = [__v_7];
-            if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_254] = [__v_7];
+            if !unconstrained { record.virt += record.function_queries[254].weight(); } record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -19727,60 +27384,19 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 1;
-fn aiur_fn_200(
-  inp: [G; IN_200],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_200], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_200] = [__v_8];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } };
-        let __v_8: G = __r_arr[0];
-        let __v_9: G = G::from_u64(1);
-        let __v_10: G = (__v_8 + __v_9);
-        let __ret: [G; OUT_200] = [__v_10];
-        if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_201: usize = 1;
-const IN_201: usize = 1;
-const OUT_201: usize = 1;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_255: usize = 1;
+const IN_255: usize = 1;
+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_201], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
+    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
     let __v_1: G = __loaded[0];
     let __v_2: G = __loaded[1];
     let __v_3: G = __loaded[2];
@@ -19789,22 +27405,20 @@ fn aiur_fn_201(
     let __v_6: G = __loaded[5];
     let __v_7: G = __loaded[6];
     let __v_8: G = __loaded[7];
-    let __v_9: G = __loaded[8];
-    let __v_10: G = __loaded[9];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_201] = [__v_11];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __v_9: G = G::from_u64(0);
+        let __ret: [G; OUT_255] = [__v_9];
+        if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = G::from_u64(1);
-        let __v_13: G = (__v_11 + __v_12);
-        let __ret: [G; OUT_201] = [__v_13];
-        if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8]; 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 { let __r = record.function_queries[255].replay_at(__i); record.virt += __r; } 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_9: G = __r_arr[0];
+        let __v_10: G = G::from_u64(1);
+        let __v_11: G = (__v_9 + __v_10);
+        let __ret: [G; OUT_255] = [__v_11];
+        if !unconstrained { record.virt += record.function_queries[255].weight(); } record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19814,31 +27428,36 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 2;
-const IN_202: usize = 2;
-const OUT_202: usize = 4;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_256: usize = 2;
+const IN_256: usize = 2;
+const OUT_256: usize = 8;
+fn aiur_fn_256(
+  inp: [G; IN_256],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; 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 { let __r = record.function_queries[259].replay_at(__i); record.virt += __r; } 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_2: G = __r_arr[0];
-    let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+    let __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 { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } 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];
     let __v_4: G = __loaded[1];
     let __v_5: G = __loaded[2];
     let __v_6: G = __loaded[3];
     let __v_7: G = __loaded[4];
     let __v_8: G = __loaded[5];
+    let __v_9: G = __loaded[6];
+    let __v_10: G = __loaded[7];
+    let __v_11: G = __loaded[8];
+    let __v_12: G = __loaded[9];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_202] = [__v_4, __v_5, __v_6, __v_7];
-        if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_256] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        if !unconstrained { record.virt += record.function_queries[256].weight(); } record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
@@ -19848,119 +27467,85 @@ fn aiur_fn_202(
   })
 }
 
-const INPUT_SIZE_203: usize = 1;
-const IN_203: usize = 1;
-const OUT_203: usize = 1;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_257: usize = 2;
+const IN_257: usize = 2;
+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_203], ExecError> {
+) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
-    let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    let __v_4: G = __loaded[3];
-    let __v_5: G = __loaded[4];
-    let __v_6: G = __loaded[5];
-    let __v_7: G = __loaded[6];
-    let __v_8: G = __loaded[7];
+    let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_203] = [__v_9];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
       0u64 => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } };
-        let __v_9: G = __r_arr[0];
-        let __v_10: G = G::from_u64(1);
-        let __v_11: G = (__v_9 + __v_10);
-        let __ret: [G; OUT_203] = [__v_11];
-        if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_257] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_204: usize = 1;
-const IN_204: usize = 1;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_204], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      1u64 => {
-        let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_204] = [__v_4];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } };
+        let __v_2: G = G::from_u64(1);
+        let __v_3: G = (__v_1 - __v_2);
+        let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_3]; 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 { let __r = record.function_queries[257].replay_at(__i); record.virt += __r; } 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_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_204] = [__v_6];
-        if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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: 4 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __v_5: G = __loaded[0];
+        let __v_6: G = __loaded[1];
+        let __v_7: G = __loaded[2];
+        let __v_8: G = __loaded[3];
+        match __v_5.as_canonical_u64() {
+          0u64 => {
+            let __ret: [G; OUT_257] = [__v_8];
+            if !unconstrained { record.virt += record.function_queries[257].weight(); } record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
+            return Ok(__ret);
+          },
+          _ => {
+            return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64()));
+          },
+        }
       },
     }
   })
 }
 
-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_258: usize = 2;
+const IN_258: usize = 2;
+const OUT_258: usize = 1;
+fn aiur_fn_258(
+  inp: [G; IN_258],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_205], ExecError> {
+) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_205] = [__v_0];
-        if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_258] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __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 { let __r = record.function_queries[258].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
+        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
+        let __v_9: G = __loaded[4];
+        let __v_10: G = __loaded[5];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_205] = [__v_8];
-            if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_258] = [__v_10];
+            if !unconstrained { record.virt += record.function_queries[258].weight(); } record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -19972,40 +27557,45 @@ fn aiur_fn_205(
   })
 }
 
-const INPUT_SIZE_206: usize = 2;
-const IN_206: usize = 2;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
+const INPUT_SIZE_259: usize = 2;
+const IN_259: usize = 2;
+const OUT_259: usize = 1;
+fn aiur_fn_259(
+  inp: [G; IN_259],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_206], ExecError> {
+) -> Result<[G; OUT_259], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+  let __vsnap = record.virt;
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_206] = [__v_0];
-        if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+        let __ret: [G; OUT_259] = [__v_0];
+        if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
         return Ok(__ret);
       },
       _ => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = (__v_1 - __v_2);
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; 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 { let __r = record.function_queries[259].replay_at(__i); record.virt += __r; } 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_4: G = __r_arr[0];
-        let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
+        let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { let __r = __mq.replay_at(__ptr_usize); record.virt += __r; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
         let __v_6: G = __loaded[1];
         let __v_7: G = __loaded[2];
         let __v_8: G = __loaded[3];
         let __v_9: G = __loaded[4];
         let __v_10: G = __loaded[5];
+        let __v_11: G = __loaded[6];
+        let __v_12: G = __loaded[7];
+        let __v_13: G = __loaded[8];
+        let __v_14: G = __loaded[9];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_206] = [__v_10];
-            if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); };
+            let __ret: [G; OUT_259] = [__v_14];
+            if !unconstrained { record.virt += record.function_queries[259].weight(); } record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained, record.virt - __vsnap);
             return Ok(__ret);
           },
           _ => {
@@ -21059,6 +28649,271 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_206(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
+    207u64 => {
+      let __inp: [G; IN_207] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_207(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    208u64 => {
+      let __inp: [G; IN_208] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_208(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    209u64 => {
+      let __inp: [G; IN_209] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_209(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    210u64 => {
+      let __inp: [G; IN_210] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_210(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    211u64 => {
+      let __inp: [G; IN_211] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_211(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    212u64 => {
+      let __inp: [G; IN_212] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_212(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    213u64 => {
+      let __inp: [G; IN_213] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_213(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    214u64 => {
+      let __inp: [G; IN_214] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_214(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    215u64 => {
+      let __inp: [G; IN_215] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_215(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    216u64 => {
+      let __inp: [G; IN_216] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_216(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    217u64 => {
+      let __inp: [G; IN_217] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_217(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    218u64 => {
+      let __inp: [G; IN_218] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_218(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    219u64 => {
+      let __inp: [G; IN_219] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_219(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    220u64 => {
+      let __inp: [G; IN_220] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_220(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    221u64 => {
+      let __inp: [G; IN_221] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_221(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    222u64 => {
+      let __inp: [G; IN_222] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_222(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    223u64 => {
+      let __inp: [G; IN_223] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_223(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    224u64 => {
+      let __inp: [G; IN_224] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_224(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    225u64 => {
+      let __inp: [G; IN_225] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_225(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    226u64 => {
+      let __inp: [G; IN_226] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_226(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    227u64 => {
+      let __inp: [G; IN_227] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_227(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    228u64 => {
+      let __inp: [G; IN_228] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_228(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    229u64 => {
+      let __inp: [G; IN_229] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_229(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    230u64 => {
+      let __inp: [G; IN_230] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_230(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    231u64 => {
+      let __inp: [G; IN_231] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_231(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    232u64 => {
+      let __inp: [G; IN_232] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_232(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    233u64 => {
+      let __inp: [G; IN_233] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_233(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    234u64 => {
+      let __inp: [G; IN_234] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_234(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    235u64 => {
+      let __inp: [G; IN_235] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_235(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    236u64 => {
+      let __inp: [G; IN_236] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_236(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    237u64 => {
+      let __inp: [G; IN_237] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_237(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    238u64 => {
+      let __inp: [G; IN_238] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_238(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    239u64 => {
+      let __inp: [G; IN_239] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_239(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    240u64 => {
+      let __inp: [G; IN_240] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_240(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    241u64 => {
+      let __inp: [G; IN_241] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_241(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    242u64 => {
+      let __inp: [G; IN_242] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_242(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    243u64 => {
+      let __inp: [G; IN_243] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_243(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    244u64 => {
+      let __inp: [G; IN_244] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_244(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    245u64 => {
+      let __inp: [G; IN_245] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_245(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    246u64 => {
+      let __inp: [G; IN_246] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_246(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    247u64 => {
+      let __inp: [G; IN_247] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_247(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    248u64 => {
+      let __inp: [G; IN_248] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_248(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    249u64 => {
+      let __inp: [G; IN_249] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_249(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    250u64 => {
+      let __inp: [G; IN_250] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_250(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    251u64 => {
+      let __inp: [G; IN_251] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_251(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    252u64 => {
+      let __inp: [G; IN_252] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_252(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    253u64 => {
+      let __inp: [G; IN_253] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_253(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    254u64 => {
+      let __inp: [G; IN_254] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_254(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    255u64 => {
+      let __inp: [G; IN_255] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_255(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    256u64 => {
+      let __inp: [G; IN_256] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_256(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    257u64 => {
+      let __inp: [G; IN_257] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_257(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    258u64 => {
+      let __inp: [G; IN_258] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_258(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    259u64 => {
+      let __inp: [G; IN_259] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_259(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
index 720fce56f..e42a5bab8 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs
@@ -24,6 +24,183 @@ use aiur::G;
 use aiur::bytecode::{FunIdx, Toplevel};
 use aiur::execute::{ExecError, IOBuffer, IOKeyInfo, QueryRecord};
 
+/// One content-addressed preimage consumed by `join_two` on IO channel 4.
+/// The digest is keyed in the same packed-four-byte form as an Aiur public
+/// digest; the circuit re-hashes `bytes` before using the decoded claim.
+#[derive(Clone, Copy, Debug)]
+pub struct JoinPreimage<'a> {
+  pub digest: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// One serialized `AssumptionTree` consumed by `join_two` on IO channel 5.
+/// Tree roots use the kernel's address key representation: one field element
+/// per byte, rather than the packed public-digest representation.
+#[derive(Clone, Copy, Debug)]
+pub struct JoinTree<'a> {
+  pub root: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// One carried/discharged choice consumed by `join_two_structural` on IO
+/// channel 6. Candidates use the same raw-address key representation as trees;
+/// the circuit strictly parses the choice and verifies every discharge path.
+#[derive(Clone, Copy, Debug)]
+pub struct JoinPath<'a> {
+  pub candidate: [u8; 32],
+  pub bytes: &'a [u8],
+}
+
+/// Raw advice for one binary aggregate-first join.
+///
+/// This is deliberately a borrowed view: real shard and recursive proofs are
+/// multi-megabyte blobs, so constructing an IO buffer must not first clone the
+/// caller's byte arrays into an intermediate owned request object.
+#[derive(Clone, Copy, Debug)]
+pub struct JoinAdvice<'a> {
+  pub proofs: [&'a [u8]; 2],
+  pub recursion_vk: &'a [u8],
+  pub child_claims: [&'a [u8]; 2],
+  pub output_claim: &'a [u8],
+  pub allowed: &'a [u8],
+  pub preimages: &'a [JoinPreimage<'a>],
+  pub trees: &'a [JoinTree<'a>],
+  pub paths: &'a [JoinPath<'a>],
+}
+
+/// Decode the compact host/FFI representation of digest-addressed join
+/// preimages. The wire format is a little-endian `u32` entry count followed
+/// by `(32-byte key, u32 payload length, payload)` entries.
+pub fn decode_join_preimages(
+  blob: &[u8],
+) -> Result<Vec<JoinPreimage<'_>>, String> {
+  decode_keyed_blobs(blob, "join preimages").map(|entries| {
+    entries
+      .into_iter()
+      .map(|(digest, bytes)| JoinPreimage { digest, bytes })
+      .collect()
+  })
+}
+
+/// Decode the compact host/FFI representation of root-addressed join trees.
+/// Its framing is identical to [`decode_join_preimages`].
+pub fn decode_join_trees(blob: &[u8]) -> Result<Vec<JoinTree<'_>>, String> {
+  decode_keyed_blobs(blob, "join trees").map(|entries| {
+    entries.into_iter().map(|(root, bytes)| JoinTree { root, bytes }).collect()
+  })
+}
+
+/// Decode the compact candidate-addressed structural-discharge choices. Its
+/// framing is identical to [`decode_join_preimages`]; payload semantics are
+/// checked by the circuit.
+pub fn decode_join_paths(blob: &[u8]) -> Result<Vec<JoinPath<'_>>, String> {
+  decode_keyed_blobs(blob, "join paths").map(|entries| {
+    entries
+      .into_iter()
+      .map(|(candidate, bytes)| JoinPath { candidate, bytes })
+      .collect()
+  })
+}
+
+fn decode_keyed_blobs<'a>(
+  blob: &'a [u8],
+  label: &str,
+) -> Result<Vec<([u8; 32], &'a [u8])>, String> {
+  let mut cursor = 0usize;
+  let count = read_u32(blob, &mut cursor, label)? as usize;
+  let max_entries = blob.len().saturating_sub(cursor) / 36;
+  if count > max_entries {
+    return Err(format!(
+      "{label}: declares {count} entries, but the blob can contain at most \
+       {max_entries} complete key/length headers"
+    ));
+  }
+  let mut entries = Vec::with_capacity(count);
+  for entry_index in 0..count {
+    let key_end = cursor.checked_add(32).ok_or_else(|| {
+      format!("{label}: entry {entry_index} key offset overflow")
+    })?;
+    let key_slice = blob.get(cursor..key_end).ok_or_else(|| {
+      format!("{label}: truncated 32-byte key for entry {entry_index}")
+    })?;
+    let key: [u8; 32] =
+      key_slice.try_into().expect("slice length was checked above");
+    cursor = key_end;
+
+    let payload_len = read_u32(blob, &mut cursor, label)? as usize;
+    let payload_end = cursor.checked_add(payload_len).ok_or_else(|| {
+      format!("{label}: entry {entry_index} payload offset overflow")
+    })?;
+    let payload = blob.get(cursor..payload_end).ok_or_else(|| {
+      format!(
+        "{label}: entry {entry_index} declares {payload_len} payload bytes, \
+         but only {} remain",
+        blob.len().saturating_sub(cursor)
+      )
+    })?;
+    cursor = payload_end;
+    entries.push((key, payload));
+  }
+  if cursor != blob.len() {
+    return Err(format!(
+      "{label}: {} trailing bytes after {count} entries",
+      blob.len() - cursor
+    ));
+  }
+  Ok(entries)
+}
+
+fn read_u32(
+  blob: &[u8],
+  cursor: &mut usize,
+  label: &str,
+) -> Result<u32, String> {
+  let end = cursor
+    .checked_add(4)
+    .ok_or_else(|| format!("{label}: length offset overflow"))?;
+  let bytes: [u8; 4] = blob
+    .get(*cursor..end)
+    .ok_or_else(|| format!("{label}: truncated u32 length"))?
+    .try_into()
+    .expect("slice length was checked above");
+  *cursor = end;
+  Ok(u32::from_le_bytes(bytes))
+}
+
+/// Append one keyed byte stream to an IO channel arena.
+#[inline]
+fn extend_bytes(io: &mut IOBuffer, channel: G, key: Vec<G>, bytes: &[u8]) {
+  let arena = io.data.entry(channel).or_default();
+  let idx = arena.len();
+  let len = bytes.len();
+  arena.extend(bytes.iter().map(|b| G::from_u8(*b)));
+  io.map.insert((channel, key), IOKeyInfo { idx, len });
+}
+
+/// An integer stream index (`[0]`, `[1]`, or `[2]`) as an Aiur IO key.
+#[inline]
+fn index_key(index: u8) -> Vec<G> {
+  vec![G::from_u8(index)]
+}
+
+/// A Blake3 digest as eight packed little-endian `u32` field elements.
+/// Mirrors in-circuit `b3_pack` and Lean `MultiStark.digestGs`.
+#[inline]
+fn packed_digest_key(digest: &[u8; 32]) -> Vec<G> {
+  digest
+    .as_chunks::<4>()
+    .0
+    .iter()
+    .map(|word| G::from_u32(u32::from_le_bytes(*word)))
+    .collect()
+}
+
+/// A 32-byte address as 32 field elements, matching the IxVM tree-loader key.
+#[inline]
+fn address_key(address: &[u8; 32]) -> Vec<G> {
+  address.iter().map(|b| G::from_u8(*b)).collect()
+}
+
 /// Mirror of `Toplevel::execute` (same return shape, same
 /// `entry`-flag gate), but routes execution through the codegen'd
 /// Rust verifier. Deep recursion is handled via per-fn
@@ -41,7 +218,8 @@ pub fn execute_multi_stark(
   if !toplevel.functions[fun_idx].entry {
     return Err(ExecError::NotEntryFunction(fun_idx));
   }
-  let mut record = QueryRecord::new(toplevel);
+  // The recursive verifier is never profiled.
+  let mut record = QueryRecord::new(toplevel, false);
   let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?;
   Ok((record, output))
 }
@@ -61,13 +239,154 @@ pub fn verifier_io_buffer(proof: &[u8], vk: &[u8], claims: &[u8]) -> IOBuffer {
   }
   let mut io =
     IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() };
-  for (channel, bytes) in
-    [(0u64, proof), (1, vk), (2, claims)].map(|(c, b)| (G::from_u64(c), b))
-  {
-    let data: Vec<G> = bytes.iter().map(|b| G::from_u8(*b)).collect();
-    let len = data.len();
-    io.data.insert(channel, data);
-    io.map.insert((channel, vec![G::ZERO]), IOKeyInfo { idx: 0, len });
+  for (channel, bytes) in [(0u8, proof), (1, vk), (2, claims)] {
+    extend_bytes(&mut io, G::from_u8(channel), index_key(0), bytes);
   }
   io
 }
+
+/// Build the flat/structural join entrypoints' seven-channel IO advice buffer.
+///
+/// Layout (the circuit binds every digest-addressed blob before decoding):
+///
+/// * ch 0 `[0]`, `[1]`: left/right recursive proof bytes;
+/// * ch 1 `[0]`: the recursion system verifying key;
+/// * ch 2 `[0]`, `[1]`, `[2]`: child outer claims and output `CheckEnv` claim;
+/// * ch 3 `[0]`: the digest-bound allowed-vk blob;
+/// * ch 4 `packed(blake3)`: nested claim preimages;
+/// * ch 5 `root bytes`: serialized subject/assumption trees;
+/// * ch 6 `candidate bytes`: carried/discharged choices and Merkle paths.
+pub fn join_io_buffer(advice: &JoinAdvice<'_>) -> IOBuffer {
+  let mut io =
+    IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() };
+
+  extend_bytes(&mut io, G::from_u8(0), index_key(0), advice.proofs[0]);
+  extend_bytes(&mut io, G::from_u8(0), index_key(1), advice.proofs[1]);
+  extend_bytes(&mut io, G::from_u8(1), index_key(0), advice.recursion_vk);
+  extend_bytes(&mut io, G::from_u8(2), index_key(0), advice.child_claims[0]);
+  extend_bytes(&mut io, G::from_u8(2), index_key(1), advice.child_claims[1]);
+  extend_bytes(&mut io, G::from_u8(2), index_key(2), advice.output_claim);
+  extend_bytes(&mut io, G::from_u8(3), index_key(0), advice.allowed);
+
+  for preimage in advice.preimages {
+    extend_bytes(
+      &mut io,
+      G::from_u8(4),
+      packed_digest_key(&preimage.digest),
+      preimage.bytes,
+    );
+  }
+  for tree in advice.trees {
+    extend_bytes(&mut io, G::from_u8(5), address_key(&tree.root), tree.bytes);
+  }
+  for path in advice.paths {
+    extend_bytes(
+      &mut io,
+      G::from_u8(6),
+      address_key(&path.candidate),
+      path.bytes,
+    );
+  }
+
+  io
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use multi_stark::p3_field::PrimeField64;
+
+  fn info(io: &IOBuffer, channel: u8, key: Vec<G>) -> (usize, usize) {
+    let info =
+      io.map.get(&(G::from_u8(channel), key)).expect("missing IO mapping");
+    (info.idx, info.len)
+  }
+
+  fn arena_bytes(io: &IOBuffer, channel: u8) -> Vec<u8> {
+    io.data[&G::from_u8(channel)]
+      .iter()
+      .map(|g| u8::try_from(g.as_canonical_u64()).expect("IO test byte"))
+      .collect()
+  }
+
+  #[test]
+  fn verifier_layout_remains_three_zero_keyed_channels() {
+    let io = verifier_io_buffer(&[1, 2], &[3], &[4, 5, 6]);
+    assert_eq!(info(&io, 0, index_key(0)), (0, 2));
+    assert_eq!(info(&io, 1, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 2, index_key(0)), (0, 3));
+    assert_eq!(arena_bytes(&io, 0), vec![1, 2]);
+    assert_eq!(arena_bytes(&io, 1), vec![3]);
+    assert_eq!(arena_bytes(&io, 2), vec![4, 5, 6]);
+  }
+
+  #[test]
+  fn join_layout_indexes_streams_and_uses_both_digest_key_encodings() {
+    let mut digest = [0u8; 32];
+    for (i, byte) in digest.iter_mut().enumerate() {
+      *byte = u8::try_from(i).expect("32-byte index");
+    }
+    let mut root = [0u8; 32];
+    for (i, byte) in root.iter_mut().enumerate() {
+      *byte = u8::try_from(31 - i).expect("32-byte reverse index");
+    }
+    let preimages = [JoinPreimage { digest, bytes: &[11, 12] }];
+    let trees = [JoinTree { root, bytes: &[13, 14, 15] }];
+    let paths = [JoinPath { candidate: root, bytes: &[1, 0] }];
+    let advice = JoinAdvice {
+      proofs: [&[1, 2], &[3]],
+      recursion_vk: &[4, 5],
+      child_claims: [&[6], &[7, 8]],
+      output_claim: &[9],
+      allowed: &[10],
+      preimages: &preimages,
+      trees: &trees,
+      paths: &paths,
+    };
+
+    let io = join_io_buffer(&advice);
+
+    assert_eq!(arena_bytes(&io, 0), vec![1, 2, 3]);
+    assert_eq!(info(&io, 0, index_key(0)), (0, 2));
+    assert_eq!(info(&io, 0, index_key(1)), (2, 1));
+
+    assert_eq!(arena_bytes(&io, 2), vec![6, 7, 8, 9]);
+    assert_eq!(info(&io, 2, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 2, index_key(1)), (1, 2));
+    assert_eq!(info(&io, 2, index_key(2)), (3, 1));
+
+    assert_eq!(info(&io, 3, index_key(0)), (0, 1));
+    assert_eq!(info(&io, 4, packed_digest_key(&digest)), (0, 2));
+    assert_eq!(info(&io, 5, address_key(&root)), (0, 3));
+    assert_eq!(info(&io, 6, address_key(&root)), (0, 2));
+    assert_ne!(packed_digest_key(&digest), address_key(&digest));
+  }
+
+  #[test]
+  fn keyed_join_blobs_decode_strictly_without_copying_payloads() {
+    let key = [7u8; 32];
+    let mut blob = Vec::new();
+    blob.extend_from_slice(&1u32.to_le_bytes());
+    blob.extend_from_slice(&key);
+    blob.extend_from_slice(&3u32.to_le_bytes());
+    blob.extend_from_slice(&[8, 9, 10]);
+
+    let preimages = decode_join_preimages(&blob).expect("valid preimage blob");
+    assert_eq!(preimages.len(), 1);
+    assert_eq!(preimages[0].digest, key);
+    assert_eq!(preimages[0].bytes, &[8, 9, 10]);
+
+    let trees = decode_join_trees(&blob).expect("valid tree blob");
+    assert_eq!(trees[0].root, key);
+    assert_eq!(trees[0].bytes, &[8, 9, 10]);
+
+    let paths = decode_join_paths(&blob).expect("valid path blob");
+    assert_eq!(paths[0].candidate, key);
+    assert_eq!(paths[0].bytes, &[8, 9, 10]);
+
+    blob.push(11);
+    assert!(decode_join_preimages(&blob).is_err());
+    assert!(decode_join_trees(&[1, 0, 0]).is_err());
+    assert!(decode_join_paths(&[1, 0, 0]).is_err());
+  }
+}
diff --git a/crates/ixvm-codegen/src/lib.rs b/crates/ixvm-codegen/src/lib.rs
index 6a3ca75e1..476613e05 100644
--- a/crates/ixvm-codegen/src/lib.rs
+++ b/crates/ixvm-codegen/src/lib.rs
@@ -3,6 +3,8 @@
 //! Bridges the `aiur` proving framework with `ixon` / `ix-common`
 //! content-addressed env types.
 
+pub mod aiur_ix_aggr;
+pub mod aiur_ix_aggr_runner;
 pub mod aiur_ixvm;
 pub mod aiur_ixvm_runner;
 pub mod aiur_ixvm_witness;
diff --git a/crates/kernel/src/claim.rs b/crates/kernel/src/claim.rs
index 46d0605c8..6c5aceb2f 100644
--- a/crates/kernel/src/claim.rs
+++ b/crates/kernel/src/claim.rs
@@ -5,10 +5,10 @@
 //! builders sit above it. They take an `Env` so they can compute the
 //! `assumptions` merkle root over the constant's transitive deps.
 //!
-//! All builders default to the *canonical* merkle builder (sorted +
-//! deduped leaves) — when recursive aggregation lands, free-form roots
-//! from `merkle_join` will also be acceptable, but builders that start
-//! from an env always produce canonical roots.
+//! These env-derived builders intentionally use the *canonical* merkle builder
+//! (sorted + deduped leaves). `Claim::CheckEnv` itself treats its root as an
+//! opaque Merkle commitment and already accepts free-form roots produced by
+//! recursive `merkle_join`; there is no canonical-root validator on claims.
 
 use rustc_hash::FxHashSet;
 
diff --git a/crates/kernel/src/def_eq.rs b/crates/kernel/src/def_eq.rs
index a97bc174c..95e67a936 100644
--- a/crates/kernel/src/def_eq.rs
+++ b/crates/kernel/src/def_eq.rs
@@ -87,8 +87,8 @@ impl<M: KernelMode> TypeChecker<'_, M> {
       eprintln!(
         "[deq] {} {} ~ {}",
         self.fuel_used(),
-        &a.hash_key(),
-        &b.hash_key(),
+        a.hash_key(),
+        b.hash_key(),
       );
     }
     if a.ptr_eq(b) {
diff --git a/crates/kernel/src/inductive.rs b/crates/kernel/src/inductive.rs
index 561c0fdca..4cad5c7bd 100644
--- a/crates/kernel/src/inductive.rs
+++ b/crates/kernel/src/inductive.rs
@@ -3969,13 +3969,7 @@ peers={} flat={} rec_ids={} failed_gi={failed_gi}",
     };
     let univ_offset = match rec_ids.first() {
       Some(rid) => match self.try_get_const(rid)? {
-        Some(KConst::Recr { lvls, .. }) => {
-          if lvls > ind_lvls {
-            1u64
-          } else {
-            0u64
-          }
-        },
+        Some(KConst::Recr { lvls, .. }) if lvls > ind_lvls => 1u64,
         _ => 0,
       },
       None => 0,
@@ -4160,8 +4154,7 @@ re-run with `IX_RECURSOR_DUMP={}` for the full breakdown.",
           generated_with_rules.len()
         )));
       }
-      for (dst, src) in cached.iter_mut().zip(generated_with_rules.into_iter())
-      {
+      for (dst, src) in cached.iter_mut().zip(generated_with_rules) {
         dst.rules = src.rules;
       }
     }
diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs
index 06cc0af81..79dce9edc 100644
--- a/crates/kernel/src/ingress.rs
+++ b/crates/kernel/src/ingress.rs
@@ -3875,17 +3875,7 @@ fn drop_ixon_env(ixon_env: IxonEnv, quiet: bool) {
   // set. Dropping them inline alongside the bookkeeping below is
   // negligible compared to the DashMap dropdance.
   // `..` covers the env's private fields.
-  let IxonEnv {
-    consts,
-    named,
-    blobs,
-    names,
-    comms,
-    anon_hints: _,
-    main: _,
-    assumptions: _,
-    ..
-  } = ixon_env;
+  let IxonEnv { consts, named, blobs, names, comms, .. } = ixon_env;
   let consts_len = consts.len();
   let named_len = named.len();
   let names_len = names.len();
diff --git a/crates/kernel/src/perf.rs b/crates/kernel/src/perf.rs
index 8f1bcf888..033a77615 100644
--- a/crates/kernel/src/perf.rs
+++ b/crates/kernel/src/perf.rs
@@ -291,7 +291,7 @@ impl PerfCounters {
     let peak = self.peak_rec_fuel_used.load(Ordering::Relaxed);
     let total = self.total_rec_fuel_used.load(Ordering::Relaxed);
     let n = self.constants_checked.load(Ordering::Relaxed);
-    let avg = if n > 0 { total / n } else { 0 };
+    let avg = total.checked_div(n).unwrap_or(0);
     writeln!(out, "[ix-perf] rec_fuel:")?;
     writeln!(
       out,
diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs
index c06d1ae9a..3a21a6480 100644
--- a/crates/kernel/src/shard.rs
+++ b/crates/kernel/src/shard.rs
@@ -2,15 +2,16 @@
 //! cross-shard delta-unfold ingress (see `plans/sharding.md`). Two driving
 //! modes share the same min-cut machinery:
 //!
-//! - **Fixed count** ([`Hypergraph::partition`], the `--shards N` CLI path):
-//!   recursive *balanced* min-cut bisection into exactly `N` shards — even
-//!   per-shard work, the bisection tree doubling as the aggregation tree.
-//! - **Cap / packing** ([`partition_for_cycle_cap`], the default and
-//!   `--max-cycles`/`--max-ram` paths): **bin-pack to the cap** — the fewest
-//!   shards that each stay under a per-shard cycle (hence prover-RAM) budget,
-//!   each filled as full as the dependency structure allows. This does *not*
-//!   balance: uniformity over-shards (every shard left partly empty), whereas
-//!   packing hits `≈⌈total/cap⌉` shards. It still uses a fine min-cut
+//! - **Fixed count** ([`Hypergraph::partition`], explicit `--shards N` and the
+//!   static strategy's `--max-ram` score seed): recursive *balanced* min-cut
+//!   bisection into exactly `N` shards — even per-shard work, the bisection tree
+//!   doubling as the aggregation tree.
+//! - **Cap / packing** ([`partition_for_cycle_cap`], the profiled strategy's
+//!   default and `--max-cycles`/`--max-ram` paths): **bin-pack to the cap** — the
+//!   fewest shards that each stay under a per-shard cycle (hence prover-RAM)
+//!   budget, each filled as full as the dependency structure allows. This does
+//!   *not* balance: uniformity over-shards (every shard left partly empty),
+//!   whereas packing hits `≈⌈total/cap⌉` shards. It still uses a fine min-cut
 //!   pre-partition for a **cut-coherent order** so dependency overlap packs into
 //!   the same shard (overlap paid once, not re-ingressed per shard).
 //!
@@ -311,16 +312,61 @@ impl AggNode {
   /// `None` when nothing remains. Lets a prover fold along the tree even when
   /// only a subset of shards was proven (empty shards, `--only-shard`).
   pub fn prune(&self, keep: &impl Fn(u32) -> bool) -> Option<AggNode> {
+    self.filter_map_leaves(&|id| keep(id).then_some(id))
+  }
+
+  /// Generalized pruning used when a manifest writer drops empty shards and
+  /// densely renumbers the retained leaves.
+  fn filter_map_leaves(
+    &self,
+    map: &impl Fn(u32) -> Option<u32>,
+  ) -> Option<AggNode> {
     match self {
-      AggNode::Leaf(id) => keep(*id).then_some(AggNode::Leaf(*id)),
-      AggNode::Internal(l, r) => match (l.prune(keep), r.prune(keep)) {
-        (Some(a), Some(b)) => Some(AggNode::Internal(Box::new(a), Box::new(b))),
-        (Some(a), None) | (None, Some(a)) => Some(a),
-        (None, None) => None,
+      AggNode::Leaf(id) => map(*id).map(AggNode::Leaf),
+      AggNode::Internal(l, r) => {
+        match (l.filter_map_leaves(map), r.filter_map_leaves(map)) {
+          (Some(a), Some(b)) => {
+            Some(AggNode::Internal(Box::new(a), Box::new(b)))
+          },
+          (Some(a), None) | (None, Some(a)) => Some(a),
+          (None, None) => None,
+        }
+      },
+    }
+  }
+
+  /// A balanced binary tree over `ids`, left to right: the left half takes
+  /// `len / 2` leaves, exactly the shape the Lean consumer builds with
+  /// `AggregationTree.balancedRange` for manifests that carry no tree.
+  /// `None` for an empty slice.
+  pub fn balanced(ids: &[u32]) -> Option<AggNode> {
+    match ids {
+      [] => None,
+      [id] => Some(AggNode::Leaf(*id)),
+      _ => {
+        let (l, r) = ids.split_at(ids.len() / 2);
+        Some(AggNode::Internal(
+          Box::new(AggNode::balanced(l)?),
+          Box::new(AggNode::balanced(r)?),
+        ))
       },
     }
   }
 
+  /// The tree with `Leaf(id)` replaced by a copy of `subtree`. Every other
+  /// node is unchanged, so an untouched sibling subtree still folds to the
+  /// same slot statements — and the same aggregate cache keys — as before.
+  pub fn replace_leaf(&self, id: u32, subtree: &AggNode) -> AggNode {
+    match self {
+      AggNode::Leaf(x) if *x == id => subtree.clone(),
+      AggNode::Leaf(x) => AggNode::Leaf(*x),
+      AggNode::Internal(l, r) => AggNode::Internal(
+        Box::new(l.replace_leaf(id, subtree)),
+        Box::new(r.replace_leaf(id, subtree)),
+      ),
+    }
+  }
+
   /// Preorder serialization: `0u8, id(4)` for a leaf; `1u8, <left>, <right>` for
   /// an internal node.
   fn put(&self, out: &mut Vec<u8>) {
@@ -1278,6 +1324,11 @@ pub struct ShardInfo {
   /// root over the foreign part of the shard's static reference closure. `None`
   /// until populated by the env-aware layer (the pure partitioner has no `Env`).
   pub assumption_root: Option<Address>,
+  /// Measured projected prover peak of this shard's executed record
+  /// (`AiurSystem::peak_prove_bytes`), recorded when the manifest was
+  /// emitted from a run that executed the shard; 0 = unmeasured (planner
+  /// output). The scheduling signal: STARK prove wall is ~linear in it.
+  pub measured_peak_bytes: u64,
 }
 
 /// The sharding manifest: the partition plus its cost metrics. Assumption-tree
@@ -1345,6 +1396,7 @@ impl ShardManifest {
         foreign_blocks,
         cross_ingress,
         assumption_root: None,
+        measured_peak_bytes: 0,
       });
     }
     ShardManifest {
@@ -1383,9 +1435,28 @@ impl ShardManifest {
     let empty = self.shards.iter().filter(|s| s.blocks.is_empty()).count();
     let max_cross =
       self.shards.iter().map(|s| s.cross_ingress).max().unwrap_or(0);
+    let peaks: Vec<u64> = self
+      .shards
+      .iter()
+      .map(|s| s.measured_peak_bytes)
+      .filter(|&p| p != 0)
+      .collect();
+    #[allow(clippy::cast_precision_loss)]
+    let measured = if peaks.is_empty() {
+      String::new()
+    } else {
+      let gib = |b: u64| b as f64 / (1u64 << 30) as f64;
+      format!(
+        " measured-peaks[{}/{} shards, min={:.1} max={:.1} GiB]",
+        peaks.len(),
+        self.shards.len(),
+        gib(peaks.iter().copied().min().unwrap_or(0)),
+        gib(peaks.iter().copied().max().unwrap_or(0)),
+      )
+    };
     format!(
       "shards={} (empty={}) heartbeats[min={} mean={} max={}] imbalance={:.2}x \
-       cross_ingress_total={} max_shard_cross={}",
+       cross_ingress_total={} max_shard_cross={}{measured}",
       self.shards.len(),
       empty,
       min,
@@ -1399,18 +1470,41 @@ impl ShardManifest {
 
   /// Serialize to the `.ixes` binary format.
   pub fn to_bytes(&self) -> Vec<u8> {
+    use rustc_hash::FxHashMap;
+
+    // Older/fixed-count planners can leave block-empty shard records when the
+    // requested count exceeds the realizable partition. Never persist those
+    // leaves: omit them, contract the aggregation tree, and densely renumber
+    // the survivors. The Lean consumer additionally prunes zero-*constant*
+    // legacy leaves after validating them against the environment.
+    let retained: Vec<&ShardInfo> =
+      self.shards.iter().filter(|shard| !shard.blocks.is_empty()).collect();
+    let remap: FxHashMap<u32, u32> = retained
+      .iter()
+      .enumerate()
+      .map(|(new_id, shard)| (shard.id, new_id as u32))
+      .collect();
+    let tree = self
+      .tree
+      .as_ref()
+      .and_then(|tree| tree.filter_map_leaves(&|id| remap.get(&id).copied()));
+    let total_cross_ingress = retained
+      .iter()
+      .map(|shard| u128::from(shard.cross_ingress))
+      .sum::<u128>();
+
     let mut out = Vec::new();
     out.extend_from_slice(SHARD_MAGIC);
-    out.extend_from_slice(&self.total_cross_ingress.to_le_bytes());
-    out.extend_from_slice(&(self.shards.len() as u32).to_le_bytes());
+    out.extend_from_slice(&total_cross_ingress.to_le_bytes());
+    out.extend_from_slice(&(retained.len() as u32).to_le_bytes());
     let put_addrs = |out: &mut Vec<u8>, addrs: &[Address]| {
       out.extend_from_slice(&(addrs.len() as u32).to_le_bytes());
       for a in addrs {
         out.extend_from_slice(a.as_bytes());
       }
     };
-    for sh in &self.shards {
-      out.extend_from_slice(&sh.id.to_le_bytes());
+    for (new_id, sh) in retained.iter().enumerate() {
+      out.extend_from_slice(&(new_id as u32).to_le_bytes());
       out.extend_from_slice(&sh.heartbeats.to_le_bytes());
       out.extend_from_slice(&sh.own_size.to_le_bytes());
       out.extend_from_slice(&sh.cross_ingress.to_le_bytes());
@@ -1427,13 +1521,25 @@ impl ShardManifest {
     // Trailing optional bisection-tree section: presence byte then preorder
     // tree. Appended after the shards so older readers that stop at the shard
     // count simply ignore it, and `from_bytes` treats end-of-input as `None`.
-    match &self.tree {
+    match &tree {
       Some(t) => {
         out.push(1);
         t.put(&mut out);
       },
       None => out.push(0),
     }
+    // Trailing measured-peaks section (same older-readers-ignore contract
+    // as the tree): presence byte, then one u64 LE per shard in order.
+    // Absent when nothing was measured, so planner manifests stay
+    // byte-identical to the pre-peaks format.
+    if self.shards.iter().any(|s| s.measured_peak_bytes != 0) {
+      out.push(1);
+      for sh in &self.shards {
+        out.extend_from_slice(&sh.measured_peak_bytes.to_le_bytes());
+      }
+    } else {
+      out.push(0);
+    }
     out
   }
 
@@ -1462,6 +1568,7 @@ impl ShardManifest {
         foreign_blocks,
         cross_ingress,
         assumption_root,
+        measured_peak_bytes: 0,
       });
     }
     // Optional trailing tree section. Absent (end-of-input) on pre-tree
@@ -1471,6 +1578,12 @@ impl ShardManifest {
     } else {
       None
     };
+    // Optional trailing measured-peaks section; absent on older manifests.
+    if c.pos < c.buf.len() && c.u8()? == 1 {
+      for sh in &mut shards {
+        sh.measured_peak_bytes = c.u64()?;
+      }
+    }
     // The tree is the aggregation plan: a leaf set that is not exactly the
     // shard id set (each id once) would silently drop or duplicate proven
     // shards in the fold, so a manifest carrying such a tree is invalid.
@@ -1573,12 +1686,73 @@ pub const STATIC_OWNED_SUPERLINEAR: f64 = 681.08;
 /// See [`STATIC_OWNED_PER_BYTE`].
 pub const STATIC_FRONTIER_PER_BYTE: f64 = 38_000.0;
 
+/// Reference point for the profile-free shard-count seed: Mathlib's static
+/// owned-side score under this model. At a 400 GiB prover budget, 233 seed
+/// shards gave the established Mathlib-class behavior (a small number of
+/// heavy-tail splits, corrected by the execution gate).
+pub const STATIC_SEED_REFERENCE_SCORE: f64 = 1.254e14;
+/// Mathlib seed count at [`STATIC_SEED_REFERENCE_RAM_GIB`].
+pub const STATIC_SEED_REFERENCE_SHARDS: f64 = 233.0;
+/// Prover-RAM budget of the reference calibration.
+pub const STATIC_SEED_REFERENCE_RAM_GIB: f64 = 400.0;
+/// Mild superlinear scale correction over the static owned-side score.
+///
+/// A linear score model still over-counted the small environments: cross-shard
+/// duplication and the heavy-tail risk both grow with library scale. The 1.10
+/// exponent preserves the Mathlib reference while fitting the measured knees
+/// at Init (8 shards) and ISLB (23) at the 400 GiB reference budget.
+pub const STATIC_SEED_SCORE_EXPONENT: f64 = 1.10;
+/// Superlinear correction when scaling the seed away from 400 GiB.
+///
+/// Fitted on the 2026-08-28 100 GiB calibration: linear scaling caused broad
+/// correction (Init 32→48 leaves; ISLB 93→123), while 1.20 seeded Init at 43
+/// (42 measured clean) and ISLB at 122 (four initial misses, 128 leaves).
+/// Out-of-sample Batteries seeded 74 with one initial miss and 79 leaves. The
+/// discarded 1.36 candidate over-seeded ISLB at 152→156. Unlike the score
+/// exponent, this changes no reference-budget prediction.
+pub const STATIC_SEED_BUDGET_EXPONENT: f64 = 1.20;
+
 /// Predicted owned-side cost of one block under the static model.
 fn static_owned_weight(size: u32) -> f64 {
   let s = f64::from(size);
   STATIC_OWNED_PER_BYTE * s + STATIC_OWNED_SUPERLINEAR * s * s.sqrt()
 }
 
+/// Whole-environment owned-side score used only to seed a shard count.
+///
+/// There is no frontier when the environment is viewed as one set, so this is
+/// just the sum of [`static_owned_weight`] over blocks. Unlike raw `.ixe` file
+/// bytes, it sees how bytes are packaged: the superlinear term distinguishes a
+/// large reduction-heavy proof body from the same bytes spread over many small
+/// declarations. The actual partition still includes frontier cost and is
+/// always checked by the execution-time prover-RAM gate.
+pub fn static_env_score(profile: &BlockProfile) -> f64 {
+  profile.blocks().iter().map(|b| static_owned_weight(b.serialized_size)).sum()
+}
+
+/// Score/budget model for the profile-free shard-count seed.
+///
+/// This deliberately rounds to the nearest shard instead of always rounding
+/// upward: it is a seed, not a safety boundary, and the prove/check execution
+/// gate measures and splits every over-budget shard before a STARK starts.
+/// Avoiding an unconditional upward bias matters most for small environments.
+fn static_seed_shards_for_score(score: f64, ram_gib: u64) -> usize {
+  let budget = ram_gib.max(1) as f64;
+  let scaled = STATIC_SEED_REFERENCE_SHARDS
+    * (score / STATIC_SEED_REFERENCE_SCORE).powf(STATIC_SEED_SCORE_EXPONENT)
+    * (STATIC_SEED_REFERENCE_RAM_GIB / budget)
+      .powf(STATIC_SEED_BUDGET_EXPONENT);
+  scaled.round().max(1.0) as usize
+}
+
+/// Suggested static seed count for `profile` at a per-shard prover-RAM budget.
+/// The result is capped at one shard per atomic block; finer partitioning could
+/// only create empty shards and cannot make an oversized block splittable.
+pub fn static_seed_shards(profile: &BlockProfile, ram_gib: u64) -> usize {
+  static_seed_shards_for_score(static_env_score(profile), ram_gib)
+    .min(profile.num_blocks().max(1))
+}
+
 /// Greedy global rebalance toward equal predicted per-shard cost under the
 /// static model. Repeatedly moves the best block from the most expensive
 /// shard to the cheapest until the hot/cold gap is within 1% of the mean
@@ -1797,14 +1971,7 @@ pub fn shard_static(
   );
   let mut manifest =
     ShardManifest::build(profile, &shard_of, num_shards).with_tree(tree);
-  for shard in &mut manifest.shards {
-    shard.assumption_root =
-      ixon::merkle::merkle_root_canonical(&shard.foreign_blocks);
-  }
-  if let Some(op) = out_path {
-    std::fs::write(op, manifest.to_bytes())
-      .map_err(|e| format!("write {op}: {e}"))?;
-  }
+  seal_and_write(&mut manifest, out_path)?;
   let costs = static_predicted_costs(profile, &shard_of, num_shards);
   let (mut lo, mut hi, mut sum) = (f64::INFINITY, 0.0f64, 0.0f64);
   for &c in &costs {
@@ -1849,14 +2016,7 @@ pub fn shard_esp(
   let (shard_of, tree) = h.partition_with_tree(num_shards, balance);
   let mut manifest =
     ShardManifest::build(&profile, &shard_of, num_shards).with_tree(tree);
-  for shard in &mut manifest.shards {
-    shard.assumption_root =
-      ixon::merkle::merkle_root_canonical(&shard.foreign_blocks);
-  }
-  if let Some(op) = out_path {
-    std::fs::write(op, manifest.to_bytes())
-      .map_err(|e| format!("write {op}: {e}"))?;
-  }
+  seal_and_write(&mut manifest, out_path)?;
   // The largest single block's heartbeats is the *floor* on achievable
   // per-shard balance: a mutual block is atomic and cannot be split, so no
   // partition can drive max-shard heartbeats below it. When the heaviest shard
@@ -1885,6 +2045,245 @@ pub fn shard_esp(
   ))
 }
 
+/// Seal every shard's assumption root (the canonical merkle root over
+/// its foreign blocks) and write the manifest when a path is given.
+/// Shared tail of every manifest-producing entry point.
+fn seal_and_write(
+  manifest: &mut ShardManifest,
+  out_path: Option<&str>,
+) -> Result<(), String> {
+  for shard in &mut manifest.shards {
+    shard.assumption_root =
+      ixon::merkle::merkle_root_canonical(&shard.foreign_blocks);
+  }
+  if let Some(op) = out_path {
+    std::fs::write(op, manifest.to_bytes())
+      .map_err(|e| format!("write {op}: {e}"))?;
+  }
+  Ok(())
+}
+
+/// Write a `.ixes` manifest for an EXPLICIT shard assignment — the
+/// partition a prove run actually produced (splits included) rather
+/// than a planner's output. Same manifest construction as
+/// [`shard_static`]'s tail: [`ShardManifest::build`] recomputes
+/// own sizes, foreign blocks and cross-ingress from the profile, and
+/// each shard's assumption root is the canonical merkle root of its
+/// foreign blocks. No aggregation tree is attached (consumers fall
+/// back to the flat tree-fold); heartbeat figures carry whatever proxy
+/// the profile was built with (serialized size, on the static path).
+/// `peaks` (empty, or one measured prover-peak per shard in order)
+/// fills each shard's `measured_peak_bytes` — the run's measurement
+/// riding along for schedulers to bin-pack on.
+pub fn shard_manifest_explicit(
+  profile: &BlockProfile,
+  shard_of: &[u32],
+  num_shards: usize,
+  peaks: &[u64],
+  out_path: &str,
+) -> Result<String, String> {
+  if peaks.len() != num_shards {
+    return Err(format!(
+      "measured peaks: {} values for {num_shards} shards",
+      peaks.len()
+    ));
+  }
+  let mut manifest = ShardManifest::build(profile, shard_of, num_shards);
+  for (shard, &peak) in manifest.shards.iter_mut().zip(peaks) {
+    shard.measured_peak_bytes = peak;
+  }
+  seal_and_write(&mut manifest, Some(out_path))?;
+  Ok(manifest.summary())
+}
+
+/// One leaf of a source manifest cut into parts: the parts' block lists in
+/// order (each a nonempty subset of the leaf's blocks) and, per part, the
+/// measured prover peak (`0` = unmeasured).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LeafRefinement {
+  pub id: u32,
+  pub parts: Vec<Vec<Address>>,
+  pub part_peaks: Vec<u64>,
+}
+
+impl ShardManifest {
+  /// Refine this manifest by cutting some of its leaves into parts, leaving
+  /// every other leaf — block list, record, and place in the aggregation
+  /// tree — exactly as it was.
+  ///
+  /// Id policy: part 0 of a refined leaf keeps the leaf's id; the remaining
+  /// parts take fresh ids after the last existing one (ascending by refined
+  /// leaf id, then part order), so ids stay dense and untouched shards keep
+  /// their numbers. Each refined leaf's place in the tree becomes a balanced
+  /// subtree over its parts; a source without a tree first gets the balanced
+  /// tree its Lean consumer would have used. `measured` (empty, or one value
+  /// per source shard) overrides the carried-forward peak of unsplit shards
+  /// where nonzero.
+  ///
+  /// The whole new partition is validated as an exact, disjoint cover of the
+  /// profile's blocks. Returns the refined manifest (unsealed: the caller
+  /// fills assumption roots) and, per refinement, its parts' new ids.
+  pub fn refine(
+    &self,
+    profile: &BlockProfile,
+    refinements: &[LeafRefinement],
+    measured: &[u64],
+  ) -> Result<(ShardManifest, Vec<Vec<u32>>), String> {
+    use rustc_hash::FxHashMap;
+
+    let n = self.shards.len();
+    if n == 0 {
+      return Err("refine: source manifest has no shards".into());
+    }
+    for (i, sh) in self.shards.iter().enumerate() {
+      if sh.id as usize != i {
+        return Err(format!(
+          "refine: source shard ids are not dense (entry {i} has id {})",
+          sh.id
+        ));
+      }
+    }
+    if !measured.is_empty() && measured.len() != n {
+      return Err(format!(
+        "refine: measured peaks: {} values for {n} shards",
+        measured.len()
+      ));
+    }
+    let mut by_id: FxHashMap<u32, usize> = FxHashMap::default();
+    for (i, r) in refinements.iter().enumerate() {
+      if r.id as usize >= n {
+        return Err(format!(
+          "refine: shard {} is out of range ({n} shards)",
+          r.id
+        ));
+      }
+      if r.parts.len() < 2 {
+        return Err(format!(
+          "refine: shard {} needs at least two parts, got {}",
+          r.id,
+          r.parts.len()
+        ));
+      }
+      if r.part_peaks.len() != r.parts.len() {
+        return Err(format!(
+          "refine: shard {}: {} peaks for {} parts",
+          r.id,
+          r.part_peaks.len(),
+          r.parts.len()
+        ));
+      }
+      if let Some(k) = r.parts.iter().position(Vec::is_empty) {
+        return Err(format!("refine: shard {} part {k} is empty", r.id));
+      }
+      if by_id.insert(r.id, i).is_some() {
+        return Err(format!("refine: shard {} listed twice", r.id));
+      }
+    }
+
+    // The new shard list in id order: slots 0..n keep their ids (part 0 of a
+    // refined leaf inherits the leaf's), then the extra parts are appended.
+    let mut new_shards: Vec<(&[Address], u64)> = Vec::with_capacity(n);
+    let mut part_ids: Vec<Vec<u32>> = vec![Vec::new(); refinements.len()];
+    for sh in &self.shards {
+      match by_id.get(&sh.id) {
+        None => {
+          let carried = measured
+            .get(sh.id as usize)
+            .copied()
+            .filter(|&p| p != 0)
+            .unwrap_or(sh.measured_peak_bytes);
+          new_shards.push((&sh.blocks, carried));
+        },
+        Some(&i) => {
+          let r = &refinements[i];
+          new_shards.push((&r.parts[0], r.part_peaks[0]));
+          part_ids[i].push(sh.id);
+        },
+      }
+    }
+    let mut refined_ids: Vec<u32> = by_id.keys().copied().collect();
+    refined_ids.sort_unstable();
+    for id in refined_ids {
+      let i = by_id[&id];
+      let r = &refinements[i];
+      for (part, &peak) in r.parts.iter().zip(&r.part_peaks).skip(1) {
+        let new_id = u32::try_from(new_shards.len())
+          .map_err(|_| "refine: too many shards".to_string())?;
+        new_shards.push((part, peak));
+        part_ids[i].push(new_id);
+      }
+    }
+
+    // Exact cover over the profile's blocks.
+    let block_id: FxHashMap<&Address, u32> = profile
+      .blocks()
+      .iter()
+      .enumerate()
+      .map(|(i, b)| (&b.addr, i as u32))
+      .collect();
+    let mut shard_of = vec![u32::MAX; profile.num_blocks()];
+    for (k, (blocks, _)) in new_shards.iter().enumerate() {
+      for a in *blocks {
+        let Some(&b) = block_id.get(a) else {
+          return Err(format!(
+            "refine: shard {k}: block {} not in the env's block profile",
+            a.hex()
+          ));
+        };
+        if shard_of[b as usize] != u32::MAX {
+          return Err(format!(
+            "refine: block {} appears in shards {} and {k}",
+            a.hex(),
+            shard_of[b as usize]
+          ));
+        }
+        shard_of[b as usize] = k as u32;
+      }
+    }
+    let uncovered = shard_of.iter().filter(|&&s| s == u32::MAX).count();
+    if uncovered > 0 {
+      return Err(format!(
+        "refine: partition covers {} of {} blocks ({uncovered} missing)",
+        profile.num_blocks() - uncovered,
+        profile.num_blocks()
+      ));
+    }
+
+    let mut manifest =
+      ShardManifest::build(profile, &shard_of, new_shards.len());
+    for (sh, (_, peak)) in manifest.shards.iter_mut().zip(&new_shards) {
+      sh.measured_peak_bytes = *peak;
+    }
+    let all_ids: Vec<u32> = (0..n as u32).collect();
+    let mut tree = self
+      .tree
+      .clone()
+      .unwrap_or_else(|| AggNode::balanced(&all_ids).expect("n > 0 leaves"));
+    for (r, ids) in refinements.iter().zip(&part_ids) {
+      let sub = AggNode::balanced(ids).expect("at least two parts");
+      tree = tree.replace_leaf(r.id, &sub);
+    }
+    manifest.tree = Some(tree);
+    Ok((manifest, part_ids))
+  }
+}
+
+/// Refine a source manifest ([`ShardManifest::refine`]), seal the result and
+/// write it to `out_path`. Returns the manifest summary and, per refinement,
+/// its parts' new ids.
+pub fn shard_manifest_refine(
+  profile: &BlockProfile,
+  source: &ShardManifest,
+  refinements: &[LeafRefinement],
+  measured: &[u64],
+  out_path: &str,
+) -> Result<(String, Vec<Vec<u32>>), String> {
+  let (mut manifest, part_ids) =
+    source.refine(profile, refinements, measured)?;
+  seal_and_write(&mut manifest, Some(out_path))?;
+  Ok((manifest.summary(), part_ids))
+}
+
 /// Like [`shard_esp`] but sized to a per-shard Zisk **cycle** budget
 /// (`max_cycles`) rather than a fixed shard count: grows `N` until the heaviest
 /// splittable shard fits the budget (see [`partition_for_cycle_cap`]). Use
@@ -1904,14 +2303,7 @@ pub fn shard_esp_cap(
   let mut manifest =
     ShardManifest::build(&profile, &plan.shard_of, plan.num_shards)
       .with_tree(plan.tree);
-  for shard in &mut manifest.shards {
-    shard.assumption_root =
-      ixon::merkle::merkle_root_canonical(&shard.foreign_blocks);
-  }
-  if let Some(op) = out_path {
-    std::fs::write(op, manifest.to_bytes())
-      .map_err(|e| format!("write {op}: {e}"))?;
-  }
+  seal_and_write(&mut manifest, out_path)?;
   let note = if plan.infeasible_atomic_floor {
     "\n  [INFEASIBLE: a single atomic block exceeds the cap — split it upstream, raise the cap, or use a bigger box]"
   } else {
@@ -2469,6 +2861,62 @@ mod tests {
     );
   }
 
+  #[test]
+  fn static_seed_model_scales_by_score_and_budget() {
+    // 400 GiB calibration points from the 2026-08-28 sweep. Init and ISLB
+    // are the small/mid-size knees; Mathlib is the normalization point. FLT
+    // records the large-env extrapolation, not an optimum (its old corrected
+    // leaf count depended on the previous seed). These are scores, not raw
+    // env bytes.
+    assert_eq!(static_seed_shards_for_score(6.010e12, 400), 8); // Init
+    assert_eq!(static_seed_shards_for_score(1.536e13, 400), 23); // ISLB
+    assert_eq!(
+      static_seed_shards_for_score(STATIC_SEED_REFERENCE_SCORE, 400),
+      233
+    );
+    assert_eq!(static_seed_shards_for_score(1.316e14, 400), 246); // FLT
+
+    // The 100 GiB calibration keeps broad split correction out of Init and
+    // ISLB without the 1.36 experiment's over-sharding.
+    assert_eq!(static_seed_shards_for_score(6.010e12, 100), 43); // Init
+    assert_eq!(static_seed_shards_for_score(1.536e13, 100), 122); // ISLB
+    assert_eq!(
+      static_seed_shards_for_score(STATIC_SEED_REFERENCE_SCORE, 100),
+      1230
+    );
+
+    // An empty or vanishingly small score still produces a usable one-shard
+    // seed.
+    assert_eq!(static_seed_shards_for_score(0.0, 400), 1);
+  }
+
+  #[test]
+  fn static_env_score_distinguishes_block_shape() {
+    let mut concentrated = ProfileBuilder::new();
+    concentrated.block(addr(1), 0, 4000, 1, OpCounts::default());
+
+    let mut spread = ProfileBuilder::new();
+    for i in 1..=4u8 {
+      spread.block(addr(i), 0, 1000, 1, OpCounts::default());
+    }
+
+    assert!(
+      static_env_score(&concentrated.finish())
+        > static_env_score(&spread.finish())
+    );
+  }
+
+  #[test]
+  fn static_seed_count_never_exceeds_atomic_blocks() {
+    let mut b = ProfileBuilder::new();
+    for i in 1..=6u8 {
+      // Force the uncapped estimate far above six shards.
+      b.block(addr(i), 0, u32::MAX, 1, OpCounts::default());
+    }
+    let p = b.finish();
+    assert_eq!(static_seed_shards(&p, 1), p.num_blocks());
+  }
+
   #[test]
   fn objective_matches_manifest_cross_ingress() {
     let p = two_clusters();
@@ -2931,6 +3379,221 @@ mod tests {
     assert_eq!(q0.tree, None);
   }
 
+  #[test]
+  fn manifest_writer_prunes_empty_shards_and_contracts_tree() {
+    let p = two_clusters();
+    // Keep the two clusters in old shards 0 and 2, deliberately leaving shard
+    // 1 empty. Serialization must emit dense ids 0/1 and contract leaf 1.
+    let shard_of = vec![0, 0, 0, 2, 2, 2];
+    let tree = node(leaf(0), node(leaf(1), leaf(2)));
+    let m = ShardManifest::build(&p, &shard_of, 3).with_tree(tree);
+    assert!(m.shards[1].blocks.is_empty());
+
+    let q = ShardManifest::from_bytes(&m.to_bytes()).unwrap();
+    assert_eq!(q.num_shards, 2);
+    assert_eq!(q.shards.len(), 2);
+    assert_eq!(
+      q.shards.iter().map(|shard| shard.id).collect::<Vec<_>>(),
+      vec![0, 1]
+    );
+    assert!(q.shards.iter().all(|shard| !shard.blocks.is_empty()));
+    assert_eq!(q.tree, Some(node(leaf(0), leaf(1))));
+  }
+
+  fn three_way() -> (BlockProfile, ShardManifest) {
+    let p = two_clusters();
+    let shard_of = vec![0, 0, 1, 1, 2, 2];
+    let tree = node(leaf(0), node(leaf(1), leaf(2)));
+    let mut m = ShardManifest::build(&p, &shard_of, 3).with_tree(tree);
+    for sh in &mut m.shards {
+      sh.assumption_root =
+        ixon::merkle::merkle_root_canonical(&sh.foreign_blocks);
+    }
+    (p, m)
+  }
+
+  fn halves(blocks: &[Address]) -> Vec<Vec<Address>> {
+    let (a, b) = blocks.split_at(blocks.len() / 2);
+    vec![a.to_vec(), b.to_vec()]
+  }
+
+  #[test]
+  fn balanced_matches_lean_balanced_range() {
+    fn check(t: &AggNode, ids: &[u32]) {
+      let mut leaves = Vec::new();
+      t.collect_leaves(&mut leaves);
+      assert_eq!(leaves, ids);
+      if let AggNode::Internal(l, r) = t {
+        assert_eq!(l.num_leaves(), ids.len() / 2);
+        check(l, &ids[..ids.len() / 2]);
+        check(r, &ids[ids.len() / 2..]);
+      } else {
+        assert_eq!(ids.len(), 1);
+      }
+    }
+    assert_eq!(AggNode::balanced(&[]), None);
+    for n in 1..=9u32 {
+      let ids: Vec<u32> = (10..10 + n).collect();
+      check(&AggNode::balanced(&ids).unwrap(), &ids);
+    }
+  }
+
+  #[test]
+  fn replace_leaf_keeps_siblings() {
+    let t = node(leaf(0), node(leaf(1), leaf(2)));
+    let sub = node(leaf(1), leaf(3));
+    assert_eq!(
+      t.replace_leaf(1, &sub),
+      node(leaf(0), node(node(leaf(1), leaf(3)), leaf(2)))
+    );
+    assert_eq!(t.replace_leaf(7, &sub), t);
+  }
+
+  #[test]
+  fn refine_replaces_one_leaf_keeps_others_identical() {
+    let (p, m) = three_way();
+    let parts = halves(&m.shards[1].blocks);
+    let r = LeafRefinement { id: 1, parts, part_peaks: vec![10, 20] };
+    let (q, ids) = m.refine(&p, &[r], &[]).unwrap();
+    assert_eq!(ids, vec![vec![1, 3]]);
+    assert_eq!(q.num_shards, 4);
+    assert_eq!(q.shards.iter().map(|s| s.id).collect::<Vec<_>>(), [0, 1, 2, 3]);
+    // Untouched leaves: same record, sealed the same way.
+    let mut sealed = q.clone();
+    for sh in &mut sealed.shards {
+      sh.assumption_root =
+        ixon::merkle::merkle_root_canonical(&sh.foreign_blocks);
+    }
+    assert_eq!(sealed.shards[0], m.shards[0]);
+    assert_eq!(sealed.shards[2], m.shards[2]);
+    // The split leaf: part 0 keeps id 1, part 1 is appended as id 3.
+    assert_eq!(q.shards[1].blocks, m.shards[1].blocks[..1]);
+    assert_eq!(q.shards[3].blocks, m.shards[1].blocks[1..]);
+    assert_eq!(q.shards[1].measured_peak_bytes, 10);
+    assert_eq!(q.shards[3].measured_peak_bytes, 20);
+    assert_eq!(
+      q.tree,
+      Some(node(leaf(0), node(node(leaf(1), leaf(3)), leaf(2))))
+    );
+    // Round trip keeps the tree and the peaks.
+    let back = ShardManifest::from_bytes(&sealed.to_bytes()).unwrap();
+    assert_eq!(back, sealed);
+  }
+
+  #[test]
+  fn refine_id_policy_reuse_then_append() {
+    let (p, m) = three_way();
+    let r0 = LeafRefinement {
+      id: 0,
+      parts: halves(&m.shards[0].blocks),
+      part_peaks: vec![0, 0],
+    };
+    let r2 = LeafRefinement {
+      id: 2,
+      parts: halves(&m.shards[2].blocks),
+      part_peaks: vec![0, 0],
+    };
+    // Order of the refinement list does not matter: fresh ids ascend by
+    // refined leaf id.
+    let (q, ids) = m.refine(&p, &[r2.clone(), r0.clone()], &[]).unwrap();
+    assert_eq!(ids, vec![vec![2, 4], vec![0, 3]]);
+    assert_eq!(q.shards[0].blocks, r0.parts[0]);
+    assert_eq!(q.shards[3].blocks, r0.parts[1]);
+    assert_eq!(q.shards[2].blocks, r2.parts[0]);
+    assert_eq!(q.shards[4].blocks, r2.parts[1]);
+    let mut sealed = q.clone();
+    for sh in &mut sealed.shards {
+      sh.assumption_root =
+        ixon::merkle::merkle_root_canonical(&sh.foreign_blocks);
+    }
+    assert_eq!(sealed.shards[1], m.shards[1]);
+    assert_eq!(
+      q.tree,
+      Some(node(node(leaf(0), leaf(3)), node(leaf(1), node(leaf(2), leaf(4)))))
+    );
+  }
+
+  #[test]
+  fn refine_empty_is_fixed_point_and_carries_peaks() {
+    let (p, mut m) = three_way();
+    m.shards[1].measured_peak_bytes = 7;
+    let (q, ids) = m.refine(&p, &[], &[]).unwrap();
+    assert!(ids.is_empty());
+    let mut sealed = q;
+    for sh in &mut sealed.shards {
+      sh.assumption_root =
+        ixon::merkle::merkle_root_canonical(&sh.foreign_blocks);
+    }
+    assert_eq!(sealed.to_bytes(), m.to_bytes());
+    // A nonzero measurement overrides a carried peak; zero keeps it.
+    let (q2, _) = m.refine(&p, &[], &[5, 0, 9]).unwrap();
+    assert_eq!(
+      q2.shards.iter().map(|s| s.measured_peak_bytes).collect::<Vec<_>>(),
+      [5, 7, 9]
+    );
+  }
+
+  #[test]
+  fn refine_without_source_tree_uses_balanced_range() {
+    let (p, mut m) = three_way();
+    m.tree = None;
+    let r = LeafRefinement {
+      id: 2,
+      parts: halves(&m.shards[2].blocks),
+      part_peaks: vec![0, 0],
+    };
+    let (q, _) = m.refine(&p, &[r], &[]).unwrap();
+    // balancedRange 0 3 = node(leaf 0, node(leaf 1, leaf 2)), then leaf 2 →
+    // node(leaf 2, leaf 3).
+    assert_eq!(
+      q.tree,
+      Some(node(leaf(0), node(leaf(1), node(leaf(2), leaf(3)))))
+    );
+  }
+
+  #[test]
+  fn refine_rejects_bad_partitions() {
+    let (p, m) = three_way();
+    let blocks = m.shards[1].blocks.clone();
+    let err = |r: LeafRefinement, measured: &[u64]| {
+      m.refine(&p, &[r], measured).unwrap_err()
+    };
+    let one = LeafRefinement {
+      id: 1,
+      parts: vec![blocks.clone()],
+      part_peaks: vec![0],
+    };
+    assert!(err(one, &[]).contains("at least two parts"));
+    let oor =
+      LeafRefinement { id: 9, parts: halves(&blocks), part_peaks: vec![0, 0] };
+    assert!(err(oor, &[]).contains("out of range"));
+    let foreign = LeafRefinement {
+      id: 1,
+      parts: vec![vec![blocks[0].clone()], vec![addr(200)]],
+      part_peaks: vec![0, 0],
+    };
+    assert!(err(foreign, &[]).contains("not in the env's block profile"));
+    let dup = LeafRefinement {
+      id: 1,
+      parts: vec![vec![blocks[0].clone()], vec![blocks[0].clone()]],
+      part_peaks: vec![0, 0],
+    };
+    assert!(err(dup, &[]).contains("appears in shards"));
+    let missing = LeafRefinement {
+      id: 1,
+      parts: vec![vec![blocks[0].clone()], vec![m.shards[0].blocks[0].clone()]],
+      part_peaks: vec![0, 0],
+    };
+    let e = err(missing, &[]);
+    assert!(e.contains("appears in shards") || e.contains("missing"), "{e}");
+    let peaks =
+      LeafRefinement { id: 1, parts: halves(&blocks), part_peaks: vec![0] };
+    assert!(err(peaks, &[]).contains("peaks for"));
+    let ok =
+      LeafRefinement { id: 1, parts: halves(&blocks), part_peaks: vec![0, 0] };
+    assert!(err(ok, &[1, 2]).contains("measured peaks"));
+  }
+
   #[test]
   fn manifest_rejects_tree_shard_mismatch() {
     let p = two_clusters();
diff --git a/crates/kernel/src/tc.rs b/crates/kernel/src/tc.rs
index 9cbf56742..851825cfe 100644
--- a/crates/kernel/src/tc.rs
+++ b/crates/kernel/src/tc.rs
@@ -914,13 +914,12 @@ impl<'a, M: KernelMode> TypeChecker<'a, M> {
     // Sharding profiler: flush the just-finished constant's heartbeats and
     // delta-unfold edges. `delta_targets` is always drained (even when
     // `cur_const` is unset) so producers never leak into the next constant.
-    if self.env.profile_sink.is_some() {
+    if let Some(sink) = self.env.profile_sink.as_mut() {
       let producers = std::mem::take(&mut self.delta_targets);
       // Always drain the op counters (even when `cur_const` is unset) so they
       // never leak into the next constant, mirroring `delta_targets`.
       let ops = crate::profile::take_op_counts();
       if let Some(addr) = self.cur_const.take() {
-        let sink = self.env.profile_sink.as_mut().unwrap();
         sink.record(addr, used, producers, ops);
       }
     }
diff --git a/crates/kernel/src/whnf.rs b/crates/kernel/src/whnf.rs
index 8c628713f..38557a953 100644
--- a/crates/kernel/src/whnf.rs
+++ b/crates/kernel/src/whnf.rs
@@ -373,7 +373,7 @@ impl<M: KernelMode> TypeChecker<'_, M> {
     // Step journal (see `IX_STEP_TRACE` in def_eq.rs); placed after the
     // quick exit to mirror the Lean kernel's `[whnf+]` site.
     if *IX_STEP_TRACE {
-      eprintln!("[whnf+] {} {}", self.fuel_used(), &e.hash_key());
+      eprintln!("[whnf+] {} {}", self.fuel_used(), e.hash_key());
     }
 
     // Context-aware cache: closed exprs use ptr only; open exprs include
@@ -2010,11 +2010,11 @@ impl<M: KernelMode> TypeChecker<'_, M> {
       Err(_) => return Ok(KSynthOutcome::Inconclusive),
     };
     if *IX_KSYNTH_LOG {
-      eprintln!("[ksynth-attempt] {}", &ctor_app.hash_key());
+      eprintln!("[ksynth-attempt] {}", ctor_app.hash_key());
     }
     if !self.is_def_eq(&major_ty_w, &ctor_ty)? {
       if *IX_KSYNTH_LOG {
-        eprintln!("[ksynth-reject] {}", &ctor_app.hash_key());
+        eprintln!("[ksynth-reject] {}", ctor_app.hash_key());
       }
       // Cheap projection reduction can report a false negative that a later
       // full comparison resolves.  Only a normal/full DefEq rejection can be
diff --git a/docs/benchmarking.md b/docs/benchmarking.md
index c6003c699..e5a566412 100644
--- a/docs/benchmarking.md
+++ b/docs/benchmarking.md
@@ -70,6 +70,13 @@ ix bench run --backend aiur --env InitStd --mode execute \
 ix bench run --backend aiur --env InitStd --mode prove \
   --consts Nat.add_comm --ixe InitStd.ixe --ceiling-gb 50
 
+# Optional aggregate W0 diagnostic: prove two singleton CheckEnv shards,
+# lift both, then benchmark one flat join. This direct tool invocation emits
+# the two child rows plus `Nat.add_comm + String.append` with join-* metrics;
+# it is deliberately not part of the scheduled one-constant CI cell.
+bench-typecheck --ixe InitStd.ixe \
+  --consts Nat.add_comm,String.append --recursive --join --json join.json
+
 # Compare a local run against main's numbers straight from bencher.dev
 # (no token needed; --consts filters to your constants — the testbed
 # holds every benched env's):
@@ -93,7 +100,7 @@ a PR tree and compare them — exactly what the PR workflow does.
 
 | backend | what it measures | tool |
 |---|---|---|
-| `aiur`    | the Aiur proof pipeline, per constant: the `ixvm` stage proves the IxVM typecheck, the `fri-verifier` stage executes and proves the in-circuit multi-stark verifier over that fresh proof (the KZG stages fold in as they land, each with its own measure prefix), closed by the pipeline ledger (total-time, pipeline-throughput, pipeline-peak-rss). Each stage's measures carry its prefix (`ixvm-prove-time`, `fri-verifier-fft-cost`, …). The whole system runs under the recursion-tuned FRI parameters. A second mode, execute, is the fast Phase-1-only signal (fft-cost, execute-time, throughput, peak-rss) — unscheduled, local/on-demand only (`!benchmark aiur execute`) | `bench-typecheck --recursive` |
+| `aiur`    | the Aiur proof pipeline, per constant: the `ixvm` stage proves the IxVM typecheck, the `fri-verifier` stage executes and proves the in-circuit multi-stark verifier over that fresh proof (the KZG stages fold in as they land, each with its own measure prefix), closed by the pipeline ledger (total-time, pipeline-throughput, pipeline-peak-rss). Each stage's measures carry its prefix (`ixvm-prove-time`, `fri-verifier-fft-cost`, …). The whole system runs under the recursion-tuned FRI parameters. A second mode, execute, is the fast Phase-1-only signal (fft-cost, execute-time, throughput, peak-rss) — unscheduled, local/on-demand only (`!benchmark aiur execute`). The direct `--recursive --join` diagnostic takes exactly two constants as singleton `CheckEnv` shards and appends one pair row carrying `join-{execute-time,fft-cost,prove-time,peak-rss,proof-size,verify-time}`; it remains unscheduled until a runner can carry W0. | `bench-typecheck --recursive` |
 | `zisk`    | ZisK VM execute: cycles, execute-time, throughput, peak-rss, constants (pre-shard closure count, same universe as aiur's), shards (the runtime-planned partition size; 1 when the closure fits) | `zisk-host` |
 | `sp1`     | SP1 VM execute (currently disabled in the registry) | `sp1-host` |
 | `ooc`     | out-of-circuit Rust kernel: whole-env row + one full-closure row per constant (`check-time` wraps only the check — the env loads once, outside every row's timed window) | `ix check-rs --json` |
@@ -101,6 +108,36 @@ a PR tree and compare them — exactly what the PR workflow does.
 | `compile` | `ix compile <env>.lean → <env>.ixe`: compile-time, file-size, constants, throughput | `ix compile --json` |
 | `decompile` | inverse of compile — `ix decompile <env>.ixe → Lean consts`: decompile-time, throughput, peak-rss, constants, file-size (input `.ixe`). Consumes the compile cell's `.ixe` rather than producing one; a malformed decompile reddens the cell. Deep roundtrip fidelity is gated by the canonical checks (`ix validate` / roundtrip tests), which need the original Lean env the `.ixe` can't supply | `ix decompile --json` |
 
+### Aggregate W0 baselines
+
+The pre-E2 lift-size pin (2026-08-28) uses the 247-function production
+recursion system, default q=100/PoW-20 parameters, and the verified
+one-constant aggregate fixture. Its lift proof is **7,986,166 bytes**;
+the containing `Ixon.Proof` wrapper is 7,986,204 bytes at store address
+`090bea6f1c976ef6677fad94f86286295b2eea751fefb7af4c82ce9f84ca1535`.
+Positive-PoW grinding may change the proof contents, but its structural byte
+length is stable. This is the WP-E2 comparison baseline.
+
+The post-E2 default-q=100/PoW-20 run (2026-08-29) produced a verified
+**7,443,023-byte** lift proof in a 7,443,061-byte wrapper at store address
+`b5644a2956b544220dbf54a4768658cb727b24737fc383200e4c475b1f2aa6b6`:
+543,143 bytes, or 6.80%, below the pre-E2 lift pin. Unlike the old per-query
+path encoding, a pruned multiproof's byte length depends on how its sampled
+query paths overlap. Positive-PoW grinding can therefore vary both contents
+and length after E2; this is a measured sample, not a byte-exact regression
+pin. The deterministic q=100/PoW-0 benchmark is the stable local signal: its
+outer proof was 7,447,279 bytes and its recursive-verifier FFT cost was
+38,850,942,825. The default-PoW debug path separately measured a
+3,861,528-byte compact inner proof, 4,304,576 bytes after expansion to
+per-query advice, and 38,311,558,162 recursive-verifier FFT cost.
+
+The historical pre-E2 `--queries 0` join wiring gate produced a 246,014-byte
+flat-join proof and 10,280,903,348 FFT cost. P3 v0.6 requires at least one FRI
+query, so the post-E2 replacement is `--queries 1` (still PoW 0): a
+397,177-byte flat-join proof, 15,204,157,391 FFT cost, 6.64 s prove time,
+11,451,486,208-byte peak RSS, and 2.69 ms native verification. These are smoke
+values, not W0 cost estimates; the q=50 join run remains a large-box benchmark.
+
 All tools emit the same rows, and all the constant-driven ones take the same
 `--consts`/`--consts-file` grammar. The ooc and zkVM cells share per-constant
 **full-closure** scope, so their delta isolates in-circuit vs out-of-circuit
diff --git a/flake.lock b/flake.lock
index a5b07edb9..58afa9671 100644
--- a/flake.lock
+++ b/flake.lock
@@ -33,17 +33,17 @@
         ]
       },
       "locked": {
-        "lastModified": 1787415051,
-        "narHash": "sha256-14ziKcXwmJ/ZihFpp3Cg6FLVPM8kCUVzR6t0iyae1hE=",
+        "lastModified": 1787430037,
+        "narHash": "sha256-0dLeEO55z4nHvSv8xb9BMoCZTbIc9IqVuId7z8oa4kA=",
         "owner": "argumentcomputer",
         "repo": "Blake3.lean",
-        "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+        "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
         "type": "github"
       },
       "original": {
         "owner": "argumentcomputer",
         "repo": "Blake3.lean",
-        "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+        "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
         "type": "github"
       }
     },
@@ -92,6 +92,22 @@
         "type": "github"
       }
     },
+    "cuda-nixpkgs": {
+      "locked": {
+        "lastModified": 1787964612,
+        "narHash": "sha256-0N9nghg3nwzX6b6qc77EzjR9cu/Z+UR66FlfsCqiURs=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "e8be7818e19ada32105a8af937a6a473b38167ca",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "fenix": {
       "inputs": {
         "nixpkgs": [
@@ -379,6 +395,7 @@
       "inputs": {
         "blake3-lean": "blake3-lean",
         "crane": "crane_2",
+        "cuda-nixpkgs": "cuda-nixpkgs",
         "fenix": "fenix_2",
         "flake-parts": "flake-parts_2",
         "lean4-nix": "lean4-nix",
diff --git a/flake.nix b/flake.nix
index 546e2f6df..d9206f5a8 100644
--- a/flake.nix
+++ b/flake.nix
@@ -14,6 +14,10 @@
     # System packages, follows lean4-nix so we stay in sync
     nixpkgs.follows = "lean4-nix/nixpkgs";
 
+    # CUDA-only packages, independently pinned so the ordinary build graph
+    # can retain lean4-nix's older Nixpkgs revision.
+    cuda-nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+
     # Lean 4 & Lake
     lean4-nix.url = "github:argumentcomputer/lean4-nix";
 
@@ -31,7 +35,7 @@
 
     # Blake3 Rust bindings for Lean
     blake3-lean = {
-      url = "github:argumentcomputer/Blake3.lean/1b0fbd2bd78b2b873e14264037af8c8b1536b9e9";
+      url = "github:argumentcomputer/Blake3.lean/e6e908bfd3af607ab44fb462fa2276a2c81addba";
       # System packages, follows lean4-nix so we stay in sync
       inputs.lean4-nix.follows = "lean4-nix";
     };
@@ -73,13 +77,34 @@
           ...
         }:
         let
+          # CUDA is opt-in and unfree. Its dedicated package set locks CUDA
+          # 13.2 without changing the default shell or ordinary package/check
+          # graph.
+          cudaPkgs = import inputs.cuda-nixpkgs {
+            inherit system;
+            config.allowUnfree = true;
+          };
+          cudaToolkit = cudaPkgs.symlinkJoin {
+            name = "ix-cuda-13.2-toolkit";
+            paths = [
+              cudaPkgs.cudaPackages_13_2.cccl
+              cudaPkgs.cudaPackages_13_2.cuda_crt
+              cudaPkgs.cudaPackages_13_2.cuda_cudart
+              cudaPkgs.cudaPackages_13_2.cuda_nvcc
+              cudaPkgs.cudaPackages_13_2.libnvvm
+            ];
+            postBuild = ''
+              ln -s lib "$out/lib64"
+            '';
+          };
+
           # Pins the Lean toolchain; a plain derivation, no overlay involved
           lean = lean4-nix.lib.${system}.fromToolchainFile ./lean-toolchain;
 
           # Pins the Rust toolchain
           rustToolchain = fenix.packages.${system}.fromToolchainFile {
             file = ./rust-toolchain.toml;
-            sha256 = "sha256-sqSWJDUxc+zaz1nBWMAJKTAGBuGWP25GCftIOlCEAtA=";
+            sha256 = "sha256-P30Tm3O7vQAE725YtDCDHGjNrSsfZO4us11UwJGZSJo=";
           };
 
           # Rust package
@@ -163,9 +188,7 @@
               ./lean-toolchain
               ./Cargo.toml
               ./Cargo.lock
-              (pkgs.lib.fileset.fileFilter
-                (f: f.hasExt "rs" || f.hasExt "toml")
-                ./crates)
+              (pkgs.lib.fileset.fileFilter (f: f.hasExt "rs" || f.hasExt "toml") ./crates)
               (pkgs.lib.fileset.fileFilter (f: f.hasExt "lean") ./.)
             ];
           };
@@ -328,19 +351,63 @@
             '';
           };
 
-          # Lean + Rust shell for host development (`cargo build`, `lake build`).
-          devShells.default = pkgs.mkShell {
-            LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
-            packages = with pkgs; [
-              pkg-config
-              openssl
-              clang
-              rustToolchain
-              rust-analyzer
-              lean
-              cargo-deny
-              valgrind
-            ];
+          devShells = {
+            # Lean + Rust shell for host development (`cargo build`, `lake build`).
+            default = pkgs.mkShell {
+              LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+              packages = with pkgs; [
+                pkg-config
+                openssl
+                clang
+                rustToolchain
+                rust-analyzer
+                lean
+                cargo-deny
+                valgrind
+              ];
+            };
+          }
+          // pkgs.lib.optionalAttrs (system == "x86_64-linux") {
+            # CUDA stays separate so CPU development does not fetch NVIDIA's
+            # toolkit. Pinning NVCC/CUDA_HOME prevents a host-level
+            # `/usr/local/cuda` from silently selecting an incompatible
+            # compiler or runtime.
+            cuda = pkgs.mkShell {
+              LIBCLANG_PATH = "${pkgs.llvmPackages.libclang.lib}/lib";
+              NVCC = "${cudaToolkit}/bin/nvcc";
+              CUDA_HOME = "${cudaToolkit}";
+              CUDA_PATH = "${cudaToolkit}";
+              MULTI_STARK_CUDA_ARCHS = "120";
+              packages =
+                (with pkgs; [
+                  pkg-config
+                  openssl
+                  clang
+                  rustToolchain
+                  rust-analyzer
+                  lean
+                  cargo-deny
+                  valgrind
+                ])
+                ++ [ cudaToolkit ];
+              shellHook = ''
+                export PATH="${cudaToolkit}/bin:$PATH"
+                export LD_LIBRARY_PATH="${cudaToolkit}/lib:${pkgs.stdenv.cc.cc.lib}/lib''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+
+                # Nix's dynamic loader does not search the host driver's
+                # library directory. Preload only libcuda to avoid mixing libc.
+                for ixCudaDriverLib in \
+                  /run/opengl-driver/lib/libcuda.so.1 \
+                  /usr/lib/x86_64-linux-gnu/libcuda.so.1 \
+                  /usr/lib64/libcuda.so.1; do
+                  if [ -e "$ixCudaDriverLib" ]; then
+                    export LD_PRELOAD="$ixCudaDriverLib''${LD_PRELOAD:+:$LD_PRELOAD}"
+                    break
+                  fi
+                done
+                unset ixCudaDriverLib
+              '';
+            };
           };
 
           # TODO: Re-enable the zkVM shells once they build in CI.
diff --git a/lake-manifest.json b/lake-manifest.json
index 9a93b385c..bcd9d4714 100644
--- a/lake-manifest.json
+++ b/lake-manifest.json
@@ -35,10 +35,10 @@
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+   "rev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "name": "Blake3",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9",
+   "inputRev": "e6e908bfd3af607ab44fb462fa2276a2c81addba",
    "inherited": false,
    "configFile": "lakefile.lean"},
   {"url": "https://github.com/argumentcomputer/LSpec",
diff --git a/lakefile.lean b/lakefile.lean
index 3f585ebb5..df68ce110 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -13,7 +13,7 @@ BLAKE3 backend to Lean's native evaluator, and that dynlib gates every
 `IxTcVerify` module, so this pin must stay at or after the revision that
 introduced the target. -/
 require Blake3 from git
-  "https://github.com/argumentcomputer/Blake3.lean" @ "1b0fbd2bd78b2b873e14264037af8c8b1536b9e9"
+  "https://github.com/argumentcomputer/Blake3.lean" @ "e6e908bfd3af607ab44fb462fa2276a2c81addba"
 
 require Cli from git
   "https://github.com/leanprover/lean4-cli" @ "v4.33.0"
@@ -184,6 +184,14 @@ lean_exe «bench-recursion-debug» where
   root := `Benchmarks.RecursionDebug
   supportInterpreter := true
 
+lean_exe «bench-aggregate-policy» where
+  root := `Benchmarks.AggregatePolicy
+  supportInterpreter := true
+  -- Keep ix_ffi ahead of Blake3's Rust staticlib. Importing the converged
+  -- aggregator makes both archives direct dependencies; Rust allocator
+  -- symbols are then resolved from ix_ffi and not pulled twice.
+  moreLinkObjs := #[ix_rs]
+
 /- The lean4lean replay machinery as an importable lib: the
 `bench-lean4lean` exe root and the ignored `lean4lean` test runner both
 import `Benchmarks.Lean4Lean`, and modules under `Benchmarks/` belong to
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index a5b578d83..23de05434 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,4 +1,4 @@
 [toolchain]
 # The default profile includes rustc, rust-std, cargo, rust-docs, rustfmt and clippy.
 profile = "default"
-channel = "1.92"
+channel = "1.98"
diff --git a/sp1/Cargo.lock b/sp1/Cargo.lock
index 0a1a98ec6..66fb34e20 100644
--- a/sp1/Cargo.lock
+++ b/sp1/Cargo.lock
@@ -290,7 +290,7 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "num-bigint 0.4.6",
 ]
diff --git a/sp1/guest/Cargo.lock b/sp1/guest/Cargo.lock
index 7ea41e7e9..a21ce1a81 100644
--- a/sp1/guest/Cargo.lock
+++ b/sp1/guest/Cargo.lock
@@ -40,7 +40,7 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "num-bigint 0.4.6",
 ]
diff --git a/zisk/Cargo.lock b/zisk/Cargo.lock
index a685b02a3..f6a8b8728 100644
--- a/zisk/Cargo.lock
+++ b/zisk/Cargo.lock
@@ -786,7 +786,7 @@ checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "num-bigint",
 ]
diff --git a/zisk/agg-guest/Cargo.lock b/zisk/agg-guest/Cargo.lock
index b69c70429..55b8da879 100644
--- a/zisk/agg-guest/Cargo.lock
+++ b/zisk/agg-guest/Cargo.lock
@@ -212,7 +212,7 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "num-bigint",
 ]
diff --git a/zisk/guest/Cargo.lock b/zisk/guest/Cargo.lock
index 528b4de77..fab480ef6 100644
--- a/zisk/guest/Cargo.lock
+++ b/zisk/guest/Cargo.lock
@@ -212,7 +212,7 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 [[package]]
 name = "bignat"
 version = "0.1.0"
-source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=2a9c91eba44ea791978a086a6a19b3a922edfee5#2a9c91eba44ea791978a086a6a19b3a922edfee5"
+source = "git+https://github.com/argumentcomputer/lean-ffi.git?rev=93c7e52952ae94546be08313f4ff3922984c84d5#93c7e52952ae94546be08313f4ff3922984c84d5"
 dependencies = [
  "num-bigint",
 ]